gRPC և REST. API ստեղծելու երկու մոտեցումների համեմատություն
gRPC-ն և REST-ը API ստեղծելու ամենահաճախ օգտագործվող երկու մոտեցումներն են։ Պարզեք, թե ինչ է յուրաքանչյուրը, ինչ առանձնահատկություններ ունի և ինչ է առաջարկում։
Այսօր կցանկանայի ավելի մանրամասն դիտարկել gRPC-ն և REST-ը՝ ամենայն հավանականությամբ այսօր API ստեղծելու համար ամենահաճախ օգտագործվող երկու մոտեցումները։ ԵՒ՛ gRPC-ն, և՛ REST-ը առանցքային դեր են խաղում ժամանակակից API ճարտարապետություններում, հատկապես բաց կոդով և միկրոսերվիսների վրա հիմնված համակարգերում։ Մասնավորապես gRPC-ն հնարավորություն է տալիս արդյունավետ հաղորդակցություն HTTP/2.0 արձանագրությամբ և աջակցում է բազմաթիվ ծրագրավորման լեզուներ, ինչը հեշտացնում է ժամանակակից հավելվածների մշակումը։
Սկզբում համառոտ կբնութագրեմ յուրաքանչյուր գործիքը՝ ինչ է այն և ինչ է առաջարկում։ Դրանից հետո կհամեմատեմ դրանք յոթ կատեգորիաներով, որոնք ես համարում եմ ամենակարևորը ժամանակակից համակարգերի համար։
Ահա կատեգորիաները՝
- Հիմքում ընկած Http արձանագրությունները
- Աջակցվող տվյալների ձևաչափերը
- Տվյալների չափը
- Թողունակությունը
- Սահմանումները
- Ներդրման հեշտությունը
- Գործիքակազմի աջակցությունը
Ինչո՞ւ է սա կարևոր
Հիշատակեք API-ն, և մարդկանց մեծ մասը անմիջապես կպատկերացնի REST API։ Սակայն REST-ը API ստեղծելու բազմաթիվ եղանակներից միայն մեկն է, և այն չի լուծում բոլոր դեպքերը։ Գոյություն ունեն այլ մոտեցումներ, RPC-ն (Remote Procedure Call) դրանցից միայն մեկն է, իսկ gRPC-ն, թերևս, RPC իրականացնելու ամենահաջողված ֆրեյմվորքն է։ Հենց դա է պատճառը, որ gRPC-ն և REST-ը համեմատելու հարցը տեղին է։
Թեև gRPC-ն բավականին հասուն և արդյունավետ տեխնոլոգիա է, այն դեռ ընկալվում է որպես նոր։ Արդյունքում այն ավելի քիչ տարածված է, քան REST-ը, չնայած որոշ դեպքերում շատ հարմար է։ Այնպիսի հնարավորություններ, ինչպիսին կոդի գեներացիան է, որը gRPC-ում ներկառուցված է, REST-ի դեպքում հաճախ պահանջում են երրորդ կողմի գործիքներ։
Այս բլոգի գրառման հիմնական դրդապատճառը gRPC-ն ավելի հայտնի դարձնելն է և այն դեպքերը ընդգծելը, որտեղ այն իսկապես փայլում է։
Ի՞նչ է REST-ը
REST-ը, որը կրճատումն է Representational State Transfer արտահայտության, հավանաբար ցանկացած տեսակի API բացահայտող հավելված ստեղծելու ամենատարածված եղանակն է։ Նրա հաղորդակցությունը հիմնված է HTTP-ի վրա, ինչը թույլ է տալիս օգտվել այն ամենից, ինչ առաջարկում է HTTP-ն, օրինակ՝ քեշավորումից։
REST API-ն երկար ժամանակ եղել է վեբ հավելվածների համար հիմնական ընտրությունը, քանի որ՝
- Այն հիմնվում է HTTP-ի՝ վեբի արձանագրության վրա։
- Այն պարզ է և հարմար օգտագործման համար, հատկապես այնպիսի գործիքների հետ, ինչպիսիք են բրաուզերներն ու curl-ը։
- Այն աշխատում է բրաուզերների, սարքերի և լեզուների լայն շրջանակում։
Բացի այդ, քանի որ սկզբից իսկ առանց վիճակի (stateless) է, REST-ը հեշտացնում է կլիենտի և սերվերի տարանջատումը։ Արդյունավետ հաղորդակցվելու համար կլիենտին պարզապես անհրաժեշտ է իմանալ սերվերի բացահայտած ինտերֆեյսը, և այն ոչ մի կերպ կախված չէ սերվերի իրականացումից։ Կլիենտն ու սերվերը շփվում են հարցում-պատասխան սկզբունքով, որտեղ յուրաքանչյուր հարցում դասական http հարցում է։
REST-ը ո՛չ արձանագրություն է, ո՛չ (որոշ չափով) գործիք. այն ճարտարապետական մոտեցում է հավելվածներ ստեղծելու համար։ REST-ի սկզբունքներով ստեղծված սերվիսները կոչվում են RESTFul սերվիսներ։ Լինելով ճարտարապետություն՝ այն մի շարք սահմանափակումներ է դնում իր օգտագործողների վրա։
Մասնավորապես՝
- կլիենտ-սերվեր հաղորդակցություն
- առանց վիճակի հաղորդակցություն
- քեշավորում
- միասնական ինտերֆեյս
- շերտավոր համակարգ
- կոդ ըստ պահանջի
REST-ը հենվում է երկու հիմնական գաղափարի վրա՝
- endpoint-ներ. եզակի URL (Uniform Resource Locator), որը ներկայացնում է տվյալ ռեսուրսը։ Դա կարելի է պատկերացնել որպես Ինտերնետով որոշակի գործողության կամ տվյալի տարրին հասնելու միջոց
- ռեսուրս. տվյալների կոնկրետ մաս, որը բացահայտվում է տվյալ URL-ի տակ
Գոյություն ունի նաև այսպես կոչված Richardson Maturing Model-ը՝ մոդել, որը նկարագրում է, թե որքան «պրոֆեսիոնալ» է REST API-ն։ Կախված տվյալ API-ի ունեցած հատկանիշներից՝ այն REST API-ները դասում է 3 մակարդակներից (կամ 4-ից, եթե հաշվենք 0 մակարդակը) մեկի վրա։
Այդ հատկանիշներից մեկն այն է, որ REST endpoint-ը URL-ում պետք է օգտագործի գոյականներ, իսկ իր ռեսուրսները կառավարելու համար՝ HTTP հարցումների համապատասխան մեթոդներ։
Օրինակ՝
DELETE user/1 ՝ GET user/deleteById/1-ի փոխարեն
HTTP մեթոդները համապատասխանում են գործողություններին հետևյալ կերպ՝
- GET – ստանալ տվյալ ռեսուրսը կամ ռեսուրսների հավաքածուն
- POST – ստեղծել նոր ռեսուրս
- PUT – ամբողջ ռեսուրսի upsert
- PATCH – մասնակի թարմացնել տվյալ ռեսուրսը
- DELETE – ջնջել տվյալ ռեսուրսը ըստ id-ի
Հասունության մոդելն ընդգրկում է շատ ավելին, օրինակ՝ HyperMedia կոչվող հասկացությունը։ HyperMedia-ն կապում է տվյալների ներկայացման եղանակը և այն գործողությունները, որոնք կարող են կատարել կլիենտները։
Հասունության մոդելի ամբողջական նկարագրությունն այս բլոգի շրջանակներից դուրս է. դրա մասին ավելին կարող եք գտնել այստեղ։
Զգուշացում. այս պարբերության մեջ նշվածներից շատերն ավելի նրբերանգավոր են, քան ներկայացված է։ REST-ը ընդարձակ թեմա է, որը արժանի է մի ամբողջ հոդվածաշարի։ Այդուհանդերձ, այստեղ ասվածը համահունչ է REST API-ի լայնորեն հայտնի լավագույն փորձին։
Ի՞նչ է gRPC-ն
Սա Remote Procedure Call-ի բավականին հին գաղափարի ևս մեկ իրականացում է։ Այն ստեղծվել է Google-ի մարդկանց կողմից, այստեղից էլ անվանման g-ն։ Հավանաբար սա RPC-ների հետ աշխատելու ամենաժամանակակից և արդյունավետ գործիքն է, ինչպես նաև CNCF incubation նախագիծ է։
gRRC-ն սերիալիզացիայի համար հենվում է Google-ի Protocol Buffers-ի վրա, իսկ տվյալների փոխանցման միջավայր՝ HTTP/2-ի վրա, թեև gRPC-ն կարող է որպես տվյալների շերտ օգտագործել նաև JSON։
gRPC-ի հիմնական կառուցողական բլոկներն են՝
- մեթոդ. gRPC-ի հիմնարար բլոկը. յուրաքանչյուր մեթոդ հեռավոր ընթացակարգի կանչ է, որը ստանում է որևէ մուտք և արտադրում ելք։ Այն կատարում է մեկ գործողություն, որն այնուհետև իրականացվում է ձեր ընտրած ցանկացած ծրագրավորման լեզվով։ Այս պահին gRPC-ն աջակցում է մեթոդների 4 տեսակ՝ element listy
- Unary – դասական հարցում-պատասխան մոդելը, որտեղ մեթոդը ստանում է մուտք և արտադրում ելք
- Server Streaming – մեթոդները որպես մուտք ստանում են մեկ հաղորդագրություն և որպես ելք վերադարձնում հաղորդագրությունների հոսք։ gRPC-ն երաշխավորում է, որ մեկ RPC կանչի շրջանակներում հաղորդագրությունները պահպանում են իրենց հերթականությունը։
- Client Streaming – մեթոդը որպես մուտք ստանում է հաղորդագրությունների հոսք, մշակում է դրանք, մինչև չվերջանան, ապա որպես ելք վերադարձնում է մեկ հաղորդագրություն։ Ինչպես վերևում, gRPC-ն երաշխավորում է, որ մեկ RPC կանչի շրջանակներում հաղորդագրությունները պահպանում են իրենց հերթականությունը
- Bidirectional Streaming – մեթոդը որպես մուտք ստանում է հոսք և որպես ելք վերադարձնում հոսք՝ փաստորեն օգտագործելով երկու հոսք, մեկը կարդալու, մյուսը՝ գրելու համար։ Երկու հոսքերը աշխատում են միմյանցից անկախ, իսկ հաղորդագրությունների հերթականությունը պահպանվում է հոսքի մակարդակում
- սերվիս. մեթոդների խումբ. յուրաքանչյուր մեթոդ պետք է ունենա սերվիսի ներսում եզակի անուն։ Սերվիսները սահմանում են նաև այնպիսի ասպեկտներ, ինչպիսիք են անվտանգությունը, timeout-ները կամ կրկնակի փորձերը (retries)։
- հաղորդագրություն. օբյեկտ, որը ներկայացնում է մեթոդների մուտքը կամ ելքը։
gRPC API-ի սահմանումները գրվում են որպես .proto ֆայլեր, որոնք ներառում են վերը թվարկված բոլոր երեք հիմնական բլոկները։ gRPC-ն ունի նաև protocol buffer կոմպիլյատոր, որը մեր .proto ֆայլերից արտադրում է կլիենտի և սերվիսի կոդ։
Սերվերային կողմի մեթոդները կարելի է իրականացնել ցանկացած եղանակով։ Մեզ պարզապես պետք է պահպանել API-ի մուտք-ելք պայմանագիրը։
Կլիենտային կողմում կա կլիենտ (կամ stub) կոչվող օբյեկտ՝ նման http կլիենտին։ Այն տեղյակ է սերվերի բոլոր մեթոդների մասին և պարզապես հոգ է տանում հեռավոր ընթացակարգերի կանչի և դրանց պատասխանները վերադարձնելու մասին։
gRPC և REST – համեմատություն
Հիմքում ընկած HTTP արձանագրությունը
Այս առաջին կատեգորիան, հավանաբար, ամենակարևորն է, քանի որ դրա ազդեցությունը երևում է նաև մյուսների մեջ։
Ընդհանուր առմամբ, REST-ը հետևում է հարցում-պատասխան մոդելին և փոխանցման համար հենվում է HTTP/1.1-ի վրա։ Ցանկացած տեսակի streaming-ի կամ երկարատև կապերի համար մեզ անհրաժեշտ է այլ արձանագրություն, օրինակ՝ WebSocket (դրանց մասին ավելին կարող եք կարդալ այստեղ)։
Մենք կարող ենք նաև գրել որոշ «հաքերային» կոդ, որպեսզի REST-ը streaming հիշեցնի։ Ավելին, քանի որ օգտագործում է HTTP/1.1, REST-ին անհրաժեշտ է առանձին կապ յուրաքանչյուր հարցում-պատասխան փոխանակման համար։ Սա կարող է խնդիրներ առաջացնել երկարատև հարցումների կամ ցանցի սահմանափակ թողունակության դեպքում։
Բնականաբար, HTTP/2-ը կարող է օգտագործվել նաև REST-ի նման API-ներ ստեղծելու համար, սակայն HTTP/2-ը դեռ աջակցվում է ոչ բոլոր սերվերների և գրադարանների կողմից, ուստի խնդիրներ կարող են առաջանալ այլ տեղերում։
gRPC-ն, ընդհակառակը, աշխատում է բացառապես HTTP/2-ով։ Սա հնարավորություն է տալիս մեկ TCP կապով ուղարկել բազմաթիվ հարցում-պատասխան զույգեր, ինչը կարող է մեր հավելվածին զգալի արագություն տալ։ Ավելին, HTTP/2 օգտագործելով՝ gRPC-ն օգտվում է այնպիսի առաջադեմ հնարավորություններից, ինչպիսին flow control-ն է, որը թույլ է տալիս տվյալները արդյունավետ փոխանցել երկկողմանի streaming-ի ժամանակ։
Արդյունք. նեղ հաղթանակ gRPC-ի համար
Աջակցվող տվյալների ձևաչափերը
Սովորական սցենարում, երբ REST API-ն աշխատում է HTTP/1.1-ով, կարող են աջակցվել բազմաթիվ ձևաչափեր։
Որպես կանոն, REST-ը սահմանափակումներ չի դնում հաղորդագրությունների ձևաչափի կամ ոճի վրա։ Գործնականում ցանկացած ձևաչափ, որը կարելի է սերիալիզացնել սովորական տեքստի, հարմար է, այնպես որ կարող ենք ընտրել այն, ինչը լավագույնս համապատասխանում է տվյալ սցենարին։
JSON-ը, անկասկած, REST հավելվածներում տվյալներ ուղարկելու ամենահանրաճանաչ ձևաչափն է։ XML-ը երկրորդ տեղում է՝ հին/legacy հավելվածների մեծ քանակի պատճառով։
Սակայն երբ REST-ն օգտագործվում է HTTP/2-ի հետ, աջակցվում են միայն երկուական փոխանակման ձևաչափեր։ Այդ դեպքում տարբերակներ են protobuf-ը կամ avro-ն։ Այս մոտեցումն, իհարկե, ունի իր թերությունները, որոնք նկարագրված են հաջորդ կետերում։
gRPC-ն իր հերթին աջակցում է տվյալների փոխանակման ընդամենը երկու ձևաչափ՝
- Protobuf – լռելյայնը
- JSON – ավելի հին API-ի հետ ինտեգրվելու համար։
Եթե ընտրեք JSON, gRPC-ն հաղորդագրությունները կկոդավորի JSON-ով և հաղորդագրության ձևաչափ կօգտագործի GSON։ JSON-ի օգտագործումը ենթադրում է նաև լրացուցիչ կարգավորում. ահա gPRC փաստաթղթավորումը, որը բացատրում է, թե ինչպես։
Արդյունք. REST-ը հաղթում է, քանի որ աջակցում է ավելի շատ ձևաչափեր։
Տվյալների չափը
gRPC-ն լռելյայն օգտագործում է երկուական տվյալների փոխանակման ձևաչափ, որը ԶԱՆԳՎԱԾԱՅԻՆ կերպով փոքրացնում է ցանցով ուղարկվող հաղորդագրությունները։ Ըստ հետազոտությունների՝ բայթերի չափը նվազում է մոտ 40-50%-ով, իսկ իմ նախկին նախագծերից մեկում ես տեսել եմ նույնիսկ 50-70% քիչ։
Վերը նշված հոդվածը առաջարկում է JSON-ի և Protobuff-ի չափերի բավականին մանրակրկիտ համեմատություն։ Նրա հեղինակը կիսվել է նաև գործիքով, որը գեներացնում է JSON-ներ և երկուական ֆայլեր, այնպես որ կարող եք կրկնել նրա փորձերը և համեմատել արդյունքները։
Հոդվածում օգտագործված օբյեկտները բավականին պարզ են։ Այդուհանդերձ, ընդհանուր սկզբունքը մնում է ուժի մեջ. որքան շատ են ներդրված օբյեկտները և որքան բարդ է JSON-ի կառուցվածքը, այնքան այն ավելի ծանր է protobuf-ի համեմատ։ Protobuf-ի համար 50% չափի առավելությունը ողջամիտ բազային արժեք է։
REST-ի համար երկուական փոխանակման ձևաչափի օգտագործումը կարող է փոքրացնել կամ նույնիսկ վերացնել տարբերությունը։ Սակայն սա RESTful API-ներ ստեղծելու ո՛չ ամենատարածված, ո՛չ լավագույնս աջակցվող եղանակն է, ուստի կարող եք բախվել այլ խնդիրների։
Արդյունք. gRPC-ն հաղթում է լռելյայն դեպքում. եթե երկուսն էլ օգտագործում են երկուական տվյալների ձևաչափ, ոչ-ոքի է։
Թողունակություն
Կրկին, REST-ի դեպքում ամեն ինչ կախված է հիմքում ընկած HTTP արձանագրությունից և սերվերից։
HTTP/1.1-ով REST-ի լռելյայն դեպքում նույնիսկ ամենաարագ սերվերը չի գերազանցի gRPC-ին, մանավանդ եթե հաշվի առնենք JSON-ի սերիալիզացիայի և դեսերիալիզացիայի արժեքը։ Ասվածով հանդերձ, թվում է՝ տարբերությունը նվազում է, երբ անցնում ենք HTTP/2-ի։
Երբ խոսքը առավելագույն թողունակության մասին է, երկուսն էլ որպես փոխանցման միջավայր հենվում են HTTP-ի վրա, ուստի երկուսն էլ սկզբունքորեն կարող են անսահմանափակ մասշտաբավորվել։ Հետևաբար ամեն ինչ կախված է մեր օգտագործած գործիքներից և այն բանից, թե կոնկրետ ինչ է անում մեր հավելվածը, քանի որ դիզայնն ինքնին սահմանափակումներ չի դնում։
Արդյունք. gRPC-ն լռելյայն դեպքում. երկուական տվյալների և երկու կողմից HTTP/2-ի դեպքում՝ ոչ-ոքի կամ նեղ հաղթանակ gRPC-ի համար։
Սահմանումներ
Այստեղ կբացատրեմ, թե ինչպես են հաղորդագրություններն ու սերվիսները սահմանվում յուրաքանչյուր մոտեցման մեջ։
REST հավելվածների մեծ մասում մենք պարզապես հայտարարում ենք հարցումներն ու պատասխանները որպես դասեր, օբյեկտներ կամ տվյալ լեզվի առաջարկած ցանկացած կառուցվածք։ Այնուհետև հենվում ենք առկա գրադարանների վրա՝ JSON/XML/YAML-ը կամ մեզ անհրաժեշտ ցանկացած ձևաչափ սերիալիզացնելու և դեսերիալիզացնելու համար։
Կան նաև շարունակվող ջանքեր այնպիսի գործիքներ ստեղծելու համար, որոնք swagger-ով գրված REST API սահմանումներից գեներացնում են կոդ ընտրված ծրագրավորման լեզվով։ Թեև դրանք, թվում է, alpha փուլում են, այնպես որ դեռ կարող եք հանդիպել սխալների և փոքր խնդիրների, որոնք դժվարացնում են դրանց օգտագործումը։
REST հավելվածի համար երկուական և ոչ երկուական ձևաչափերը քիչ են տարբերվում, քանի որ սկզբունքը երկուսում էլ մոտավորապես նույնն է։ Երկուական ձևաչափի դեպքում մենք պարզապես սահմանում ենք ամեն ինչ այնպես, ինչպես պահանջում է տվյալ ձևաչափը։
Մենք նաև սահմանել ենք մեր REST սերվիսը՝ օգտագործելով հիմքում ընկած գրադարանի կամ ֆրեյմվորքի տրամադրած մեթոդները կամ անոտացիաները։ Այդ գործիքն այնուհետև հոգ է տանում այն, ինչպես նաև մնացած կարգավորումները, դուրս բացահայտելու մասին։
gRPC-ի դեպքում protobuf-ը լռելյայնն է և, գործնականում, սահմանումներ գրելու միակ եղանակը։ Ամեն ինչ՝ հաղորդագրությունները, սերվիսներն ու մեթոդները, պետք է հայտարարվի .proto ֆայլերում, այնպես որ ամեն ինչ բավականին պարզ է։ gRPC-ն սերվիսներն ու տվյալների կառուցվածքները սահմանում է Protocol Buffers-ի ինտերֆեյսների նկարագրության լեզվով (IDL), որը թույլ է տալիս արդյունավետ, լեզվից անկախ սերիալիզացիա և բարձրացնում է արտադրողականությունը սերվիսից սերվիս հաղորդակցության մեջ։
Այնուհետև gRPC-ի հետ տրվող գործիքը մեզ համար գեներացնում է կոդը, մեզ թողնելով միայն մեր մեթոդների իրականացումը։ Երբ դա արված է, ամեն ինչ պետք է աշխատի ըստ սպասվածի։
Protobuf-ն աջակցում է նաև import-ներ, ինչը թույլ է տալիս բավականին հեշտությամբ բաժանել մեր կարգավորումը մի քանի ֆայլերի վրա։
Արդյունք. Այս կատեգորիայում հաղթող չկա, միայն նկարագրություն և իմ խորհուրդը. ընտրեք այն մոտեցումը, որը ձեզ ավելի է համապատասխանում։
Ներդրման հեշտությունը
Այստեղ կհամեմատեմ, թե որքան լավ է յուրաքանչյուր մոտեցումն աջակցվում գրադարանների/ֆրեյմվորքների կողմից ժամանակակից ծրագրավորման լեզուներում։
Ընդհանուր առմամբ, ծրագրավորման յուրաքանչյուր լեզու (Java, Scala, Python), որին ես հանդիպել եմ ծրագրային ճարտարագիտության իմ կարճ կարիերայի ընթացքում, առաջարկում է REST-նման հավելվածներ ստեղծելու համար առնվազն 3 հիմնական գրադարան/ֆրեյմվորք, և մոտավորապես նույնքան գրադարան՝ autospring JSON-ը օբյեկտների/դասերի վերածելու համար։
Ավելին, քանի որ REST-ը լռելյայն հենվում է մարդու համար ընթեռնելի ձևաչափերի վրա, սկսնակների համար ավելի հեշտ է դրանք վրիպազերծել և աշխատել դրանց հետ։ Սա կարող է ազդել նաև նոր հնարավորությունների մատակարարման տեմպի վրա և հեշտացնել ձեր կոդում հայտնվող սխալների վերացումը։ REST API-ները հաճախ ստեղծվում են երրորդ կողմի մշակողների հաշվառմամբ, ինչը երաշխավորում է երկարաժամկետ կայունություն և հետընթաց համատեղելիություն։
Մի խոսքով, REST-ի ոճի հավելվածների աջակցությունը առնվազն շատ լավ է։
gRPC-ն ինքը առաջարկում է կլիենտ գրադարան ավելի քան 8 հանրաճանաչ ծրագրավորման լեզվի համար։ Սովորաբար դա բավարար է, քանի որ այդ գրադարանները ներառում են gRPC API ստեղծելու համար անհրաժեշտ ամեն ինչ։ Ես նաև գիտեմ գրադարաններ, որոնք առաջարկում են ավելի բարձր մակարդակի աբստրակցիաներ Java-ի համար (Spring Boot Starter-ի միջոցով) և Scala-ի համար։
Մեկ այլ կետ այն է, որ REST-ը հիմա համարվում է գլոբալ ստանդարտ և սերվիսներ ստեղծելու լռելյայն մեկնակետ, մինչդեռ RPC-ն, և մասնավորապես gRPC-ն, դեռ ընկալվում են որպես նոր բան, թեև արդեն բավականին հին են։
Արդյունք. REST, քանի որ այն ավելի լայն է օգտագործվում և շրջապատված է շատ ավելի շատ գրադարաններով և ֆրեյմվորքներով։
Գործիքակազմի աջակցությունը
Քանի որ վերևում քննարկվեցին գրադարանները, ֆրեյմվորքները և շուկայում ընդհանուր մասնաբաժինը, այս մասը կենտրոնանում է յուրաքանչյուր ոճի համար հասանելի գործիքակազմի վրա, այսինքն՝ թեստավորման, արդյունավետության/սթրես թեստավորման և փաստաթղթավորման գործիքների վրա,
Ավտոմատացված թեստեր/Թեստեր
Սկզբի համար, REST-ի դեպքում ավտոմատացված թեստեր գրելու գործիքները կամ տարբեր գրադարանների և ֆրեյմվորքների մաս են, կամ գոյություն ունեն որպես առանձին գործիքներ, ստեղծված հենց դրա համար, օրինակ՝ rest assured։
gRPC-ի համար մենք կարող ենք գեներացնել stub և օգտագործել այն թեստերում։ Էլ ավելի խիստ լինելու համար կարող ենք գեներացված կլիենտը գործարկել որպես առանձին հավելված և դրա վրա կառուցել մեր թեստերը իրական սերվիսի դեմ։
Երբ խոսքը gRPC-ն աջակցող արտաքին գործիքների մասին է, ես գիտեմ՝
- Postman հավելվածի gRPC աջակցությունը
- JetBrains-ի HTTP կլիենտը, որը ներկառուցված է նրանց IDE-ներում և փոքր կարգավորմամբ կարող է աշխատել նաև gRPC-ի հետ
Առաջին արդյունք. REST-ը հաղթում է, թեև թվում է՝ gPRC-ի համար վիճակը լավանում է։
Արդյունավետության թեստեր
REST-ը այստեղ հստակ առավելություն ունի, քանի որ JMeter-ի կամ Gatling-ի նման գործիքները REST API-ների սթրես թեստավորումը դարձնում են բավականին պարզ։
Ցավոք, gPRC-ն նմանատիպ աջակցություն չունի։ Ես գիտեմ, որ Gatling-ի թիմը gRPC plugin-ը ներառել է Gatling-ի ընթացիկ թողարկման մեջ, այնպես որ վիճակը, թվում է, բարելավվում է։
Մինչ այժմ, սակայն, մենք ունեինք միայն մեկ ոչ պաշտոնական plugin և ghz անունով գրադարան։ Դրանք բոլորը լավն են. պարզապես աջակցությունը չի համեմատվում REST-ի ստացածի հետ։
Երկրորդ արդյունք. REST-ը հաղթում է, թեև թվում է՝ gPRC-ի համար վիճակը լավանում է. կրկին ;)
Փաստաթղթավորում
API փաստաթղթավորման հարցում REST-ը կրկին հաղթում է. OpenAPI-ն և swagger-ը լայնորեն օգտագործվում են ոլորտում և հանդիսանում են դե ֆակտո ստանդարտ։ Գրեթե ցանկացած REST գրադարան կարող է swagger փաստաթղթավորում տրամադրել անմիջապես կամ շատ քիչ ջանքով։
gRPC-ն, ցավոք, համարժեք չունի։
Հարցն, սակայն, այն է, թե արդյոք gRPC-ին առհասարակ պետք է նման գործիք։ gPRC-ն ըստ դիզայնի ավելի նկարագրական է, քան REST-ը, ուստի լրացուցիչ փաստաթղթավորման գործիքները կարող են .
Ընդհանուր առմամբ, մեր API-ը նկարագրող .proto ֆայլերն ավելի դեկլարատիվ և լակոնիկ են, քան REST API ստեղծող կոդը, այնպես որ գուցե gPRC-ին որևէ լրացուցիչ փաստաթղթավորում պետք չէ։ Թողնում եմ ձեզ որոշել։
Երրորդ արդյունք. REST-ը հաղթում է, բայց հարցը, թե gRPC-ին փաստաթղթավորում պետք է, թե ոչ, մնում է բաց։
gRPC-ի և REST-ի մրցակցության ընդհանուր արդյունք. REST-ի հստակ հաղթանակ։
gRPC և REST – ամփոփում
Ահա թե ինչպես է տեսք ունի վերջնական միավորների աղյուսակը։
Միավորները հավասարապես բաժանված են երկու ոճերի միջև. երեքական հաղթանակ և մեկ կատեգորիա առանց հստակ հաղթողի։
Չկա արծաթե գնդակ (silver bullet). մտածեք, թե որ կատեգորիաներն են ձեր հավելվածի համար ամենակարևորը, և ընտրեք այն մոտեցումը, որը դուրս եկավ առաջին տեղում դրանց մեծ մասում։ Համենայն դեպս, իմ խորհուրդը սա է։
Անձամբ ես կփորձեի gRPC-ն, երբ հնարավորություն լինի, քանի որ այն իսկապես լավ ծառայեց ինձ իմ վերջին նախագծում։ Այն կարող է ավելի լավ ընտրություն լինել, քան լավ հին REST-ը։
Շնորհակալություն ձեր ժամանակի համար։