Գնահատել նախագիծը
← Բոլոր հրապարակումները

SSE թե՞ WebSockets. իրական ժամանակի հաղորդակցման արձանագրությունների համեմատություն

Server Sent Events (SSE) և WebSockets տեխնոլոգիաների ակնարկ, որը նկարագրում է դրանց հնարավորությունները և համեմատում է դրանք ժամանակակից վեբ համակարգերի համար կարևոր հիմնական կատեգորիաներով։ Նպատակն է օգնել ձեզ որոշել՝ վեբ մշակման մեջ իրական ժամանակի հաղորդակցության համար այս երկու տեխնոլոգիաներից որն օգտագործել։

11 րոպե
SSEWebsocketՀաղորդակցման արձանագրություններ

Այս հոդվածում ուզում եմ ավելի մոտիկից քննել Server Sent Events-ը (կարճ՝ SSE) և WebSockets-ը։ Երկուսն էլ տվյալների փոխանակման ամուր, փորձված եղանակներ են։

Կսկսեմ յուրաքանչյուր գործիքի համառոտ բնութագրից՝ թե ինչ է այն և ինչ է տալիս։ Դրանից հետո կհամեմատեմ դրանք ութ կատեգորիաներով, որոնք համարում եմ ամենակարևորը ժամանակակից համակարգերի համար։

Ահա կատեգորիաները.

  1. Հաղորդակցության ուղղությունը
  2. Հիմքում ընկած արձանագրությունը
  3. Անվտանգություն
  4. Պարզություն
  5. Արտադրողականություն
  6. Հաղորդագրության կառուցվածքը
  7. Ընդունման դյուրինություն
  8. Գործիքակազմ

REST-ի և qRPC-ի իմ նախորդ համեմատությունից տարբերվելով՝ ես հաղթող չեմ հայտարարի և յուրաքանչյուր կատեգորիայում միավորներ չեմ շնորհի։ Փոխարենը Ամփոփում բաժինը պարունակում է մի տեսակ TL;DR աղյուսակ, որը թվարկում է այս երկու տեխնոլոգիաների հիմնական տարբերությունները վերը նշված ոլորտներում։

Ինչո՞ւ

REST-ից տարբերվելով՝ SSE-ն և WebSockets-ը երկուսն էլ ավելի շատ կենտրոնացած են կոնկրետ օգտագործման դեպքերի վրա։ Այստեղ երկու հայեցակարգերի հիմնական նպատակը «իրական ժամանակի» հաղորդակցման ալիք ապահովելն է։ Այս ավելի նեղ կենտրոնացումը դրանք դարձնում է ավելի քիչ տարածված, քան REST-ը, որը ավելի ընդհանուր, «բոլորի համար հարմար» տիպի գործիք է։

Այդուհանդերձ, SSE-ն և WebSockets-ը երկուսն էլ բացում են հետաքրքիր հնարավորությունների շրջանակ և մի փոքր փոփոխություն են առաջարկում խնդիրները լուծելու REST-ի դասական եղանակից։

Կարծում եմ՝ արժե դրանց մասին իմանալ և տեղ հատկացնել մեր գործիքակազմում, քանի որ մի օր դրանք կարող են օգտակար լինել՝ բավական բարդ խնդրին ավելի պարզ պատասխան տալով։ Սա հատկապես ճիշտ է, երբ ձեզ անհրաժեշտ են «իրական ժամանակի» թարմացումներ կամ երբ ձեր հավելվածը պահանջում է ավելի push-ուղղվածություն ունեցող մոտեցում։

Բացի դրանք այստեղ նկարագրելուց և համեմատելուց՝ ուզում եմ նաև օգնել, որ դրանք ավելի տարածված դառնան։

Ինչ է WebSockets-ը

Կարճ ասած՝ սա հաղորդակցման արձանագրություն է, որը հնարավորություն է տալիս երկկողմանի հաղորդակցության սերվերի և կլիենտի միջև մեկ երկարակյաց TCP կապի միջոցով։ Դրա շնորհիվ մեզ պետք չէ անընդհատ սերվերից թարմ տվյալներ քաշել (pull). փոխարենը շահագրգիռ կողմերը տվյալներ են փոխանակում «իրական ժամանակում»։ Յուրաքանչյուր հաղորդագրություն կա՛մ երկուական տվյալներ է, կա՛մ Unicode տեքստ։

IETF-ը ստանդարտացրեց արձանագրությունը 2011 թվականին՝ որպես RFC 6455։ WebSocket արձանագրությունը առանձին է HTTP-ից, սակայն երկուսն էլ գտնվում են OSI մոդելի 7-րդ մակարդակում և հենվում են 4-րդ մակարդակի TCP-ի վրա։

Արձանագրությունն ունի իր սեփական նախածանցները, որոնք աշխատում են գրեթե այնպես, ինչպես HTTP-ի http և https նախածանցները.

  • ws -> նշանակում է, որ կապը TLS-ով պաշտպանված չէ
  • wss -> նշանակում է, որ կապը TLS-ով պաշտպանված է

Ավելին, անվտանգ չհամարվող WebSockets կապերը (ws) չպետք է բացվեն անվտանգ կայքերից (https), և նույն կերպ՝ անվտանգ WebSockets կապերը (wss) չպետք է բացվեն ոչ անվտանգ կայքերից (http)։

Միաժամանակ WebSocket-ը նախագծված է աշխատելու HTTP-ի 443 և 80 պորտերով և աջակցում է HTTP-ի հասկացություններին, ինչպիսիք են պրոքսիներն ու միջնորդները։ Բացի այդ, WebSocket handshake-ը հենվում է HTTP upgrade header-ի վրա՝ արձանագրությունը HTTP-ից WebSocket-ի փոխելու համար։

WebSocket-ի՝ որպես արձանագրության, հիմնական թույլ կողմը անվտանգությունն է։ Քանի որ WebSocket-ը չի ենթարկվում same-origin policy-ին, CSRF տիպի հարձակումները կարող են շատ ավելի հեշտանալ։

սխեմա 2

Ինչ է Server Sent Events-ը

SSE-ն տեխնոլոգիա է, որը թույլ է տալիս վեբ սերվերին թարմացումներ ուղարկել (push) վեբ էջին։ Այն մտնում է HTML 5 ճշգրտման մեջ և, ինչպես WebSockets-ը, տվյալները «իրական ժամանակում» հասցնելու համար օգտագործում է մեկ երկարակյաց HTTP կապ։ Հայեցակարգային առումով սա բավական հին տեխնոլոգիա է, որի տեսական հիմքերը գալիս են 2004 թվականից։ SSE-ն իրականացնելու առաջին փորձը կատարվել է 2006 թվականին Opera թիմի կողմից։

Ժամանակակից դիտարկիչների մեծ մասն աջակցում է SSE-ին. Microsoft Edge-ը աջակցություն ավելացրել է 2020 թվականի հունվարին։ Այն նաև կարող է լիովին օգտագործել HTTP/2-ը, ինչը վերացնում է SSE-ի ամենամեծ խնդիրներից մեկը՝ փաստացի հանելով HTTP/1.1-ի սահմանած կապերի սահմանափակումը։

Ըստ սահմանման՝ Server Sent Events-ը բաղկացած է երկու հիմնական բաղադրիչից.

  1. EventSource -> WHATWG ճշգրտման վրա հիմնված ինտերֆեյս, որն իրականացվում է դիտարկչի կողմից. այն թույլ է տալիս կլիենտին (այստեղ՝ դիտարկչին) բաժանորդագրվել իրադարձություններին։
  2. Event stream -> արձանագրություն, որը սահմանում է ստանդարտ պարզ տեքստային ձևաչափ, որին պետք է հետևեն սերվերի ուղարկած իրադարձությունները, որպեսզի EventSource կլիենտը կարողանա դրանք հասկանալ և տարածել։

Ճշգրտման համաձայն՝ իրադարձությունները կարող են կրել կամայական տեքստային տվյալներ և ընտրովի ID, և դրանք բաժանվում են նոր տողերով։ Դրանք նույնիսկ ունեն սեփական MIME տիպ՝ text/event-stream։

Ցավոք, Server Sent Events-ը որպես տեխնոլոգիա նախատեսված է միայն տեքստային հաղորդագրություններ մշակելու համար, և թեև իրադարձություններ կարող ենք ուղարկել հարմարեցված ձևաչափով, ի վերջո յուրաքանչյուր հաղորդագրություն պետք է լինի UTF-8 կոդավորմամբ տող։

Բացի այդ, SSE-ն առաջարկում է երկու իսկապես հետաքրքիր հնարավորություն.

  • Ավտոմատ վերամիացում -> Երբ կլիենտը անսպասելիորեն անջատվում է, EventSource-ը ընդմիջումներով շարունակում է փորձել վերամիանալ։
  • Հոսքի ավտոմատ վերսկսում -> EventSource-ը ավտոմատ կերպով հետևում է իր ստացած վերջին հաղորդագրության ID-ին և վերամիանալու փորձի ժամանակ ավտոմատ ուղարկում է Last-Event-ID header։

սխեմա 1

Համեմատությունը

Հաղորդակցության ուղղությունը

Դրանց միջև ամենակարևոր տարբերությունը, հավանաբար, հաղորդակցվելու եղանակն է։

  • SSE-ն առաջարկում է միայն միակողմանի հաղորդակցություն. իրադարձությունները կարող են շարժվել բացառապես սերվերից կլիենտ։
  • WebSockets-ը առաջարկում է լիարժեք երկկողմանի հաղորդակցություն՝ թույլ տալով կողմերին տեղեկատվություն փոխանակել և արձագանքել ցանկացած կողմից եկող իրադարձություններին։

Իմ կարծիքով՝ յուրաքանչյուր մոտեցում ունի իր առավելություններն ու թերությունները, ինչպես նաև օգտագործման համապատասխան դեպքերի իր շարքը։

Եթե ձեզ միայն անհրաժեշտ է կլիենտին շարունակական թարմացումների հոսք ուղարկել, SSE-ն ավելի հարմար կլինի։ Իսկ եթե այդ իրադարձություններից որևէ մեկին պետք է ինչ-որ կերպ արձագանքել, WebSocket-ը կարող է ավելի լավ ծառայել։

Տեսականորեն (և գործնականում) ամեն ինչ, ինչ հնարավոր է SSE-ով, կարելի է անել նաև WebSockets-ով, բայց այդ պահին արդեն անցնում ենք աջակցության, լուծման պարզության կամ անվտանգության հարցերին։

Հաջորդ բաժիններն անդրադառնում են այս բոլոր ոլորտներին և ոչ միայն։ Ավելին, WebSocket-ն օգտագործել բոլոր դեպքերի համար կարող է լուրջ ավելորդություն լինել, մինչդեռ SSE-ի վրա հիմնված լուծումը կարող է պարզապես ավելի հեշտ իրականացվել։

Հիմքում ընկած արձանագրությունը

Սա երկու տեխնոլոգիաների միջև ևս մեկ խոշոր տարբերություն է։

  • SSE-ն ամբողջովին կառուցված է HTTP-ի վրա և աջակցում է և՛ HTTP/1.1-ին, և՛ HTTP/2-ին։
  • WebSocket-ը, ընդհակառակը, օգտագործում է իր սեփական արձանագրությունը՝ ո՜վ զարմանք, WebSocket արձանագրությունը։

SSE-ի համար HTTP/2-ի օգտագործումը լուծում է դրա հիմնական խնդիրներից մեկը՝ զուգահեռ կապերի առավելագույն քանակի սահմանափակումը։ HTTP/1.1 ճշգրտումը սահմանափակում է, թե քանի զուգահեռ կապ կարող է բաց լինել։

Սա կարող է հանգեցնել head-of-line blocking անունով հայտնի խնդրի։ HTTP/2-ը լուծում է այն multiplexing մտցնելով, ինչը վերացնում է HOL blocking-ը հավելվածի մակարդակում։ Այնուամենայնիվ, head-of-line blocking-ը դեռ կարող է տեղի ունենալ TCP մակարդակում։

WebSocket արձանագրությունը ես որոշ մանրամասնությամբ նկարագրել եմ մի քանի պարբերություն առաջ, ուստի այստեղ կկրկնեմ միայն հիմնական կետերը։ Արձանագրությունը որոշ չափով տարբերվում է դասական HTTP-ից, թեև հենվում է HTTP upgrade header-ի վրա՝ WebSocket կապը հաստատելու և հաղորդակցման արձանագրությունը փաստացի փոխելու համար։

Այդուհանդերձ, այն կառուցված է նաև TCP-ի վրա և լիովին համատեղելի է HTTP-ի հետ։ Դրա ամենամեծ թույլ կողմը անվտանգությունն է։

Պարզություն

Ընդհանուր առմամբ՝ SSE-ի վրա հիմնված ինտեգրացիան ավելի հեշտ է կարգավորել, քան WebSocket-ինը։ Հիմնական պատճառը յուրաքանչյուր տեխնոլոգիայի օգտագործած հաղորդակցության տեսակն է։

SSE-ի միակողմանի բնույթը և դրա push մոդելը այն հայեցակարգային առումով դարձնում են ավելի պարզ։ Ավելացրեք ավտոմատ վերամիացումը և հոսքի շարունակականության աջակցությունը, որ այն տալիս է «տուփից դուրս», և այն բաների ցանկը, որոնց մենք պետք է հետևենք, զգալիորեն կրճատվում է։

Հաշվի առնելով այս բոլոր հնարավորությունները՝ SSE-ն կարելի է դիտարկել նաև որպես կլիենտի և սերվերի կապվածությունը թուլացնելու միջոց։ Ամենը, ինչ կլիենտներին պետք է իմանալ, endpoint-ն է, որը թողարկում է իրադարձությունները։

Այս սխեմայում, սակայն, կլիենտը կարող է միայն հաղորդագրություններ ստանալ, ուստի սերվերին ցանկացած տեղեկատվություն հետ ուղարկելը պահանջում է առանձին հաղորդակցման ալիք, ինչը կարող է գործերը զգալիորեն բարդացնել։

WebSocket-ի դեպքում հարցերն ավելի բարդ են։ Նախ՝ մենք պետք է զբաղվենք կապը HTTP-ից WebSocket արձանագրության բարձրացնելով (upgrade)։ Թեև սա ամենահեշտ մասն է, դա ևս մեկ բան է, որ պետք է հիշել։

Երկրորդ խնդիրը բխում է WebSockets-ի երկկողմանի բնույթից։ Մենք պետք է կառավարենք յուրաքանչյուր կապի վիճակը և զբաղվենք հաղորդագրության մշակման ընթացքում հնարավոր բոլոր բացառություններով։ Օրինակ՝ ի՞նչ կլինի, եթե հաղորդագրություններից մեկի մշակումը սերվերի կողմում բացառություն նետի։

Ապա կա վերամիացումների մշակման հարցը, որը WebSockets-ի դեպքում ամբողջովին մեր վրա է։

Կա նաև մի խնդիր, որ վերաբերում է երկու տեխնոլոգիաներին՝ երկար ապրող կապերը։

Երկուսն էլ պետք է բաց պահեն երկարակյաց կապեր՝ իրադարձությունների շարունակական հոսք հասցնելու համար։

Այդպիսի կապերի մշակումը, հատկապես մեծ մասշտաբով, կարող է դժվար լինել, քանի որ ռեսուրսները կարող են բավական արագ սպառվել։ Բացի այդ, դրանք կարող են պահանջել հատուկ կարգավորումներ, ինչպիսիք են ավելի երկար timeout-ները, և ավելի խոցելի են ցանցային կապի ցանկացած խնդրի նկատմամբ։

Անվտանգություն

Անվտանգության առումով SSE-ն առանձնահատուկ ոչինչ չէ, քանի որ փոխանցման համար օգտագործում է սովորական հին HTTP արձանագրությունը։ HTTP-ի բոլոր սովորական ուժեղ և թույլ կողմերը տարածվում են նաև SSE-ի վրա. այդքան պարզ է։

Սակայն WebSocket արձանագրության համար ընդհանուր առմամբ անվտանգությունը նրա ամենամեծ թույլ կողմերից է։ Նախ՝ Same Origin Policy-ն ընդհանրապես բացակայում է, ուստի ոչինչ չի սահմանափակում, թե ուր կարող ենք միանալ WebSockets-ով։

Կա նույնիսկ հարձակման հատուկ տեսակ, որը նախագծված է այս թույլ կողմը շահագործելու համար՝ Cross-Origin WebSocket Hijacking։ Եթե ուզում եք Same Origin Policy-ն և WebSocket-ը ավելի խորությամբ ուսումնասիրել, այս հոդվածը կարող է հետաքրքիր լինել ձեզ համար։ Դրանից բացի, WebSockets-ն արձանագրությանը հատուկ անվտանգության այլ բացեր չունի։

Իմ կարծիքով՝ բոլոր ստանդարտ կանոններն ու անվտանգության լավագույն փորձը կիրառելի են երկուսի համար էլ, ուստի պարզապես զգույշ եղեք ձեր լուծումն իրականացնելիս։

Արտադրողականություն

Իմ կարծիքով՝ արտադրողականության առումով երկու տեխնոլոգիաները հավասար են։ Դրանցից ոչ մեկն ինքնին որևէ տեսական սահմանափակում չի դնում արտադրողականության վրա։

Այդուհանդերձ, SSE-ն կարող է ավելի արագ լինել վայրկյանում ուղարկվող հաղորդագրությունների հում քանակով, քանի որ այն քիչ թե շատ հետևում է fire-and-forget սկզբունքին, մինչդեռ WebSocket-ը պետք է զբաղվի նաև կլիենտի պատասխաններով։

Այն, ինչ իսկապես կարող է ազդել երկուսի արտադրողականության վրա, մեր հավելվածում օգտագործվող հիմքային կլիենտն է և դրա իրականացումը։ Հետազոտեք, կարդացեք փաստաթղթերը, անցկացրեք ձեր սեփական սթրես-թեստերը, և կարող եք շատ հետաքրքիր պատկերացումներ ստանալ ձեր օգտագործած գործիքի կամ ձեր ամբողջ համակարգի մասին։

Հաղորդագրության կառուցվածքը

Հաղորդագրության կառուցվածքը, հավանաբար, արձանագրությունների միջև ևս մեկ հիմնական տարբերություն է։

Ինչպես նշվեց վերևում, SSE-ն զուտ տեքստային արձանագրություն է։ Հաղորդագրությունները կարող են ունենալ տարբեր ձևաչափեր և բովանդակություն, բայց ի վերջո բոլորը վերածվում են UTF-8 կոդավորմամբ տեքստի։ Բարդ ձևաչափերը կամ երկուական տվյալները տարբերակ չեն։

WebSocket-ը, ընդհակառակը, աջակցում է և՛ տեքստային, և՛ երկուական հաղորդագրություններ, ինչը թույլ է տալիս ուղարկել պատկերներ, աուդիո կամ սովորական ֆայլեր։ Պարզապես հիշեք, որ ֆայլերի մշակումը կարող է զգալի ավելորդ ծախս մտցնել։

Ընդունման դյուրինություն

Այս առումով երկու տեխնոլոգիաները շատ նման մակարդակի վրա են։ Գոյություն ունեն բազմաթիվ գործիքներ WebSockets-ի և Server Sent Events-ի աջակցություն ավելացնելու համար՝ ինչպես կլիենտի, այնպես էլ սերվերի կողմում՝ SSE-ի տեսանկյունից։

Հասուն ծրագրավորման լեզուների մեծ մասն առաջարկում է այսպիսի մեկից ավելի գրադարան։ Առանց շատ մանրամասնության մեջ մտնելու՝ ես կազմել եմ աղյուսակ, որը թվարկում է WebSockets-ի և SSE-ի աջակցություն ավելացնող հիմնական գրադարանները։

Լեզու Server Sent Events WebSockets
Java Spring (SSE), Quarkus (SSE) Spring (WebSockets), Quarkus (WebSockets)
Scala Akka (SSE), Play (SSE) Akka (WebSockets), Play (WebSockets)
JavaScript EventSource, total.js (SSE) Socket.io, total.js (WebSocekts)
Python Starlette FastAPI

Ակնհայտ է, որ մեր հավելվածում SEE կամ WebSockets ինտեգրացիա ավելացնելու համար կան բազմաթիվ հասուն տարբերակներ։ Բնականաբար, սա հասանելի բոլոր գրադարանների միայն մի փոքր նմուշ է. կան շատ ավելիները։ Իրական մարտահրավերը կարող է լինել ընտրել այն մեկը, որը լավագույնս համապատասխանում է ձեր կոնկրետ օգտագործման դեպքին։

Գործիքակազմ

Ավտոմատացված թեստեր

Ինչքան ես գիտեմ՝ ոչ SSE-ն, ոչ WebSockets-ը ավտոմատացված թեստավորման հատուկ գործիքներ չունեն։ Սակայն կարող եք բավական հեշտությամբ ստանալ նման ֆունկցիոնալություն՝ օգտագործելով Postman և collection-ներ։

Postman-ն աջակցում է և՛ Server Sent Events-ին, և՛ WebSockets-ին։ Postman collection-ների մի փոքր կախարդանքով կարող եք կառուցել թեստերի հավաքածու, որը ստուգում է՝ արդյոք ձեր endpoint-ները ճիշտ են աշխատում։

Արտադրողականության թեստեր

Արտադրողականության թեստերի համար կարող եք ընտրել կա՛մ JMeter, կա՛մ Gatling։ Ինչքան ես գիտեմ՝ դրանք արտադրողականության ընդհանուր թեստավորման երկու ամենահասուն գործիքներն են։ Բնականաբար, երկուսն էլ աջակցում են SSE-ին (JMeter, Gatling), ինչպես նաև WebSockets-ին (JMeter, Gatling)։

Հասանելի են նաև այլ գործիքներ, ինչպիսիք են sse-perf (միայն SSE), Testable կամ k6 (միայն WebSockets)։

Այս բոլոր գործիքներից իմ անձնական առաջարկը Gatling-ն է կամ k6-ը։ Երկուսն էլ, կարծես, առաջարկում են լավագույն օգտագործողի փորձառությունը և ամենից շատ պատրաստ են արտադրական օգտագործման։

Փաստաթղթավորում

Որոշ չափով գոյություն չունեն գործիքներ, որոնք նվիրված լինեն բացառապես SSE-ի կամ WebSockets-ի փաստաթղթավորմանը։ Սակայն կա AsyncAPI անունով գործիք, որը կարող է հենց այս նպատակին ծառայել երկու հայեցակարգերի համար։

Ցավոք, OpenAPI-ն, կարծես, չի աջակցում SSE-ին կամ WebSockets-ին։

Ամփոփում

Ինչպես խոստացել էի՝ ամփոփումը կարճ է և պարզ. տես ստորև։

Իմ կարծիքով՝ վերևի աղյուսակը տալիս է թեմայի և ամբողջ հոդվածի կոկիկ և հակիրճ ակնարկ։

Հիմնական տարբերությունը Հաղորդակցության ուղղությունն է, քանի որ այն սահմանում է, թե ինչի համար կարելի է օգտագործել տվյալ տեխնոլոգիան։ Հավանաբար հենց դա ամենաշատը կկշռի՝ մեկը մյուսի փոխարեն ընտրելիս։

Հաղորդագրության կառուցվածքը ևս կարող է շատ կարևոր լինել հաղորդակցման որոշակի եղանակ ընտրելիս։ Միայն պարզ տեքստային հաղորդագրությունների աջակցությունը Server Sent Events-ի հիմնական սահմանափակումն է։

Շնորհակալություն ընթերցելու համար։