|
( c" p* K0 p/ z, K 作者，罗泽轩上个月马斯克评论 Twitter App 滥用 RPC 后，与一些 Twitter 的技术主管发生了矛盾 —— 直言马斯克不懂技术。那这个马斯克都不懂的 GraphQL 到底是什么？ 
# }0 v* U+ V& |5 L1 Q 什么是 GraphQL？它有多流行？GraphQL 是一套由 Facebook 在 2015 年发布的一套面向 API 的查询操作语言相比于其他的 API 设计方式，GraphQL 允许客户端根据事先约定的数据结构组建查询语句，由服务端解析这一语句并只返回所需的内容。 / }! [5 W1 x8 A* c
这么一来，GraphQL 在提供丰富性和灵活性的同时，避免了冗余数据带来的性能损耗GraphQL 的这一特性，让它在需要跟许多复杂数据对象打交道的应用场景里大行其道，成为该环境下的不二之选2018 年 GraphQL 完成了规范的制定工作，并推出了稳定版本。
& r& {; z. \! \9 a: W* a6 Y 同年，Facebook 将 GraphQL 项目捐献给了 Linux 基金会下属的 GraphQL 基金会自那以后，GraphQL 已经在许许多多的开源项目和商业机构中落地到目前为止，市面上已经有了多个 GraphQL 的主流客户端实现。
; Y' L( X% u, J6 ~& _3 g/ [ 而服务端的实现遍布各大服务端编程语言，甚至连一些小众编程语言如 D 和 R 都有对应的实现GraphQL 的一些真实场景和挑战最为知名的采用 GraphQL 的例子，莫过于 GitHub 的 GraphQL API 了。 ) n3 a4 `5 _1 r6 b _! C- S, C
在拥抱 GraphQL 之前，GitHub 提供了 REST API 来暴露千千万万托管项目所产生的丰富数据GitHub 的 REST API 是如此的成功，以致于它成为了人们设计 REST API 时竞相模仿的典范。 * f( x# a6 A% r; l1 K! O
然而随着数据对象的变多和对象内字段的变大，REST API 开始暴露出越来越多的弊端在服务端，由于每次调用都会产生大量的数据，GitHub 为了降低成本不得不对调用频率设置严格的限制而在开发者这边，他们则不得不与这一限制做斗争。
5 a* b7 f1 J3 Y$ i# o, { 因为虽然单次调用会返回繁多的数据，但是绝大部分都是无用的开发者要想获取某一特定的信息，往往需要发起多个查询，然后编写许多胶水代码把查询结果中有意义的数据拼接成所需的内容在这一过程中，他们还不得不带上“调用次数”的镣铐。
4 b, w# G4 S q+ ^8 c! R; Y 所以 GraphQL 的出现，立刻就让 GitHub 皈依了GitHub 成为了 GraphQL 的使者保罗，为万千开发者传递福音目前 GraphQL API 已经是 GitHub API 的首选从第一次宣布对 GraphQL 的支持
6 c) h$ N- H3 |* \1 F 之后，GitHub 每一年都会发几篇关于 GraphQL 的文章为了让开发者能够迁移到 GraphQL 上来，GitHub 专门写了个交互式查询应用，开发者可以通过这个应用学习怎么编写 GraphQL然而 GraphQL 并非灵丹妙药。
- j0 x7 t) ?5 V9 P 就在最近，GitHub 废弃自己 package API 的 GraphQL 实现许多人也开始热议 GraphQL 的一些缺点GraphQL 的许多问题源自于它跟 HTTP 标准的结构差别较大，没办法简单地将 GraphQL 的一些概念映射到诸如 HTTP path/header 这样的结构中。
, N3 Z7 X1 A# A/ U0 ~& H 把 GraphQL 当作普通的 HTTP API 来处理，需要额外的开发工作如此一来，开发者如果要管理自己的 GraphQL API，就必须采用支持 GraphQL 的 API 网关才行APISIX 现在对 GraphQL 的支持 . e" D3 o( a* \. D
Apache APISIX 是一个动态、实时、高性能的 API 网关，提供负载均衡、动态上游、灰度发布、精细化路由、限流限速、服务降级、服务熔断、身份认证、可观测性等数百项功能作为 Apache 的顶级项目，APISIX 一直致力于周边生态的扩展与跟进。 # l, L# o! Q/ i2 Q
APISIX 目前支持通过 GraphQL 的一些属性进行动态路由通过该能力，我们可以只接受特定的 GraphQL 请求，或者让不同的 GraphQL 转发到不同的上游以下面的 GraphQL 语句为例：。
" l0 a2 w' d, h2 K- B1 E3 @ query getRepo { Q3 J% T8 h8 h+ |8 u
owner {$ Z# x1 O- Z9 }, E% K9 F. r# C
name
2 i% k1 G. n9 A$ Y3 ~ X* W, ` }2 h4 o+ a: l. p9 z" Z- v7 M% W
repo {& K( s: B, Q. N5 C
created
$ G; i, `2 ~$ G9 x }, i5 i& h! \1 c0 L. z
}APISIX 会提取 GraphQL 以下三个属性，用在路由当中： / J/ p, t- N0 v& M- G1 y7 l
graphql_operationgraphql_namegraphql_root_fields在上面的 GraphQL 语句中：graphql_operation 对应 querygraphql_name
; b1 a+ K. m3 o( s3 \% v 对应 getRepographql_root_fields 对应 ["owner", "repo"]让我们来创建一个路由，展示下 APISIX 对 GraphQL 的精细化路由能力curl http://127.0.0.1:9180/apisix/admin/routes/1 \
" O. m$ B" T% \9 [1 K -H X-API-KEY: edd1c9f034335f136f87ad84b625c8f1 -X PUT -i -d
1 G& f0 [: S+ V# J- `4 a {
* f+ [8 u1 e8 q$ ?; E$ J9 r9 n "methods": ["POST"],& c5 J4 A* q# N" ~9 F' _
"uri": "/graphql",
, F1 Y) P: p& k% @% b* d "vars": [7 F H, Q3 i% f3 Y% H& Z" Z/ y7 E; h
["graphql_operation", "==", "query"],0 y9 ]: S% S$ }9 M1 Y8 L
["graphql_name", "==", "getRepo"],
" @6 I8 d$ Z. c7 { ["graphql_root_fields", "has", "owner"]! L2 D S2 Y, I! H
],7 p/ h1 O( @5 f, o$ w9 O
"upstream": { u/ i' s8 t J, e
"type": "roundrobin",
6 S1 g( o5 r8 o' |* n1 P "nodes": {
. J+ C1 o/ U4 n) l "127.0.0.1:2022": 1
u2 e& o5 T( _2 B }
- A* v. t/ m! l8 a7 h& ^: C }
7 e, e7 @* a5 W& R/ J- {! | }。 * f" [$ E& i4 X8 c; J
接下来使用带有 GraphQL 语句的请求去访问：curl -i -H content-type: application/graphql \
( ]/ A7 w, G( K8 K- u! ^' }% S. P1 U. I -X POST http://127.0.0.1:9080/graphql -d
1 @5 U; l# k, ?7 d+ H- ~ query getRepo {& F+ q Q# T. _3 x1 Z A' l- d R
owner {0 }3 x% C$ J3 N3 a
name
5 ]* g% p- L. E) ] }
3 {- y( A) a) B9 |1 [* e! | repo {
% p# K8 R% W$ v1 g; P: L/ A0 ~0 t4 l created
3 J1 @. P( Z9 @7 d4 |! X2 u6 n. S0 V }" t, @( P% S% H$ d/ L: H; C6 o+ R7 W
}
* a: L& V! E1 C. c' M7 u( t0 y HTTP/1.1 200 OK3 C# F% y- F* s7 @5 T
... $ A0 o8 m8 X: [" y4 n0 c
我们可以看到请求到达了上游，这是因为查询语句匹配了全部三个条件 反之，如果我们使用不匹配的语句来访问，比如不包含 owner 字段：curl -i -H content-type: application/graphql \1 `" p ^ F( T d* y' Q* s
-X POST http://127.0.0.1:9080/graphql -d
; i+ ` D7 G+ I9 J3 n query getRepo {' h2 I+ f2 |7 a% Q$ z& A2 s O7 q
repo {: D, l/ C" [: s2 l$ b9 a% K
created. S2 e% n" Y" r; I2 Z4 i8 z
}' H7 _! F" L+ q L- `/ N4 x, h4 c
}
; G' c7 M0 F/ E4 R( j5 k HTTP/1.1 404 Not Found* Y5 G5 N8 p7 \
...。
( g/ Z- r# d3 s) f, ^ 则不会匹配对应的路由规则接下来，我们可以另外创建一个路由，让不包含 owner 字段的语句路由到别的上游：curl http://127.0.0.1:9180/apisix/admin/routes/2 \
# w+ O d1 e: H* I# @( [- D -H X-API-KEY: edd1c9f034335f136f87ad84b625c8f1 -X PUT -i -d/ b+ R. R( E8 R5 Z7 W2 S0 [
{( q$ a' d5 y# L0 ]. T
"methods": ["POST"],; a$ ]- c5 H2 B, r! `* U% |& T2 w
"uri": "/graphql",
- e3 }+ h- J" b7 Y0 L! D2 k3 c: o "vars": [
4 }- w8 H& H" R ["graphql_operation", "==", "query"],
* p) ?3 f0 D+ e. P ["graphql_name", "==", "getRepo"],
. T8 ^( Y: L. ~& Z ["graphql_root_fields", "!", "has", "owner"]
; U! p) `3 Y! C, o; r/ z( C ],
4 q( B/ p1 i0 |% w c( g "upstream": {3 a& T' j7 T6 S/ q6 P& V/ C
"type": "roundrobin",
- ~* s) M. ~# t6 c4 b7 R "nodes": {
# [4 W( T% _9 J+ ]* ?- B6 i) h "192.168.0.1:2022": 1
5 L/ W9 z Q* o/ _) H }0 b1 r0 l4 x$ d( ]: B6 `; Z3 U) E
}, S' J$ |9 Q0 O) {+ z5 n
}" Y, s$ _/ _' }9 R7 w" F8 i& y9 r
curl -i -H content-type: application/graphql \
; q$ O) k0 x8 H( G -X POST http://127.0.0.1:9080/graphql -d
+ g* l- ^( r8 j* {/ J query getRepo {
# w( @/ z" S5 O3 o, @9 k repo {# M- q2 h* A: m) p' [3 `
created* ^) [- K+ F9 `4 @0 ~
}0 T. j! \" K& c# i4 }3 S5 n
}% p v P! o( D7 N
HTTP/1.1 200 OK6 O7 q# O% ~7 N0 ]7 Q
..。 , |( P& s6 G, R. T0 L
展望 APISIX 未来对 GraphQL 的支持除了动态路由之外，APISIX 在未来也可能会根据 GraphQL 的具体字段推出更多的操作比如说，GitHub 的 GraphQL API 有专门一套针对限流的计算公式。
/ N h) U) `4 ^$ m% y! E ，我们也可以应用类似的规则来把单个 GraphQL 请求转成相应的“虚拟调用”次数，来完成 GraphQL 专属的限流工作当然，我们也可以换个思路解决问题即应用自身还是提供 REST API，由网关在最外层把 GraphQL 请求转成 REST 请求，把 REST 响应转成 GraphQL 响应。
* o& v( r2 z8 t }% O$ T; t 这种方式提供的 GraphQL API 无需开发专门的插件，就可以完成诸如 RBAC、限流、缓存等功能从插件角度来看，它就是个平平无奇的 REST API从技术角度上讲，这个思路并不难实现毕竟在 2022 年的现在，REST API 也会提供 OpenAPI spec 来作为 schema，无非是 GraphQL schema 和 OpenAPI schema 之间的互转，外加 GraphQL 特有的字段筛选罢了（当然，我必须承认，我并没有亲自实践过，或者在一些细节上存在尚待克服的挑战）。
" ]0 e6 v: [$ H 细心的读者会发现，这种方式转换得来的 GraphQL API，每次只能操作一个模型，显然无法满足 GraphQL 灵活性的要求，无非是披着 GraphQL 外衣的 REST API且慢，我还没有把话说完呢！。
" T% `7 K( X( q5 {: y' X GraphQL 有一个叫 schema stitch 的概念，允许实现者把多个 schema 组合在一起举个例子，现在有两个 API一个叫 GetEvent，另一个叫 GetLocation他们返回的类型分别是 Event 和 Location。 4 z1 a2 C$ v/ K3 `
type Event {
. \* V6 ?4 |/ X) G5 P6 ]1 x& h id: string
% \( ~1 s1 i, w1 Q& L/ |! p4 T8 _ location_id: string6 Y6 P/ H* K. j5 {9 ?
}, b, Q% A/ S' `* g/ D
+ v, J X" l- ]+ ~ type Location {
" X6 J3 l* C7 f* t. _ id: string! f6 Z, t3 n! A- q
city: string7 F! J7 p9 I+ {/ Y- X( q
}* I3 B7 e: V, \# T5 E& `5 v9 l
c& C; c% T6 ~0 [
type Query {
' U( y& J# R/ V3 Q. _2 r/ M* J" L GetEvent(id: string): Event
1 P0 y9 W% _" b' |* X" o GetLocation(id: string): Location
n: _/ a, G% ^( J } 3 q' x- K" @* _ ~
我们可以加一个配置，由这两个 API 组合成新的 API 叫 GetEventWithLocation新的 API 是这样的：type EventWithLocation {5 j" G, |: F: ^& h! L( \1 K
id: string2 P$ |- w8 V% } Z
location: Location, }: M1 n) O. e$ `% y" i+ _) |' T! k
}
( m% t' x2 I1 A. E/ }" e" J( x7 m
_! g) H6 F2 a0 F type Query { H1 V* w! L; h" i; ^5 B ~( e
GetEventWithLocation(id: string): EventWithLocation6 {/ y( t) F2 F9 S$ B& A" e3 n
}。
" Z8 X6 X7 {( m: Y' d# C. V 整体 schema stitch 的过程都由网关来完成在上面的例子中，网关会把 API 拆分成两个，先调用 GetEvent 得到 location_id，再调用 GetLocation 得到组合后的数据。 3 z' O0 R2 S' B7 @- }
总而言之，通过 REST 转 GraphQL，每个 REST API 可以变成对应的 GraphQL 模型；再借助 schema stitch，可以把多个模型组合成一个 GraphQL API这样一来，我们就能在现有的 REST API 上构建起丰富灵活的 GraphQL API，且在 REST API 的粒度上完成具体的插件管理。
, K8 Q' V9 w" M$ b 这一设计顺带解决了部分 API 编排的问题就像上面的例子中，我们把一个 API 的输出（Event.location_id）作为另一个 API 的输入（Location.id） $ M7 Y% |1 U/ z5 x l0 `' W
. w* d' H$ ]% I2 Z$ z9 B
& ?) [* d9 Z. `0 i8 c& {- K, V R: c+ g8 m$ i' D
1 C; f- C3 W8 G$ ~9 Y | 
