Unison-ի փորձարկում, մաս 4. եզրից մինչև ամպ
«Unison-ի փորձարկում» շարքի եզրափակիչ մասը։ Բացահայտեք, թե ինչպես կարող է բաշխված ծրագրավորումը դառնալ այսօրվա համեմատ շատ ավելի մատչելի՝ և իսկապես հաճելի գրելու համար
«Unison-ի փորձարկում» շարքի նախորդ մասերում սկզբում դիտարկեցինք լեզվի գլխավոր առանձնահատկությունը՝ բովանդակությամբ հասցեավորվող կոդը, որի շնորհիվ ֆունկցիայի ինքնությունը կախված է նրանից, թե ինչ է անում այն, այլ ոչ թե անունից (անունները ծառայում են պարզապես որպես պիտակներ)։ Հետո ուսումնասիրեցինք, թե դա ինչպես է ազդում կոդի կազմակերպման և կախվածությունների կառավարման վրա անվանատարածքների միջոցով։ Վերջում քննարկեցինք Unison-ի abilities-ը՝ հանրահաշվական էֆեկտների համակարգ, որը տալիս է այնպիսի հնարավորություններ, ինչպիսիք են սխալների մշակումը կամ կախվածությունների ներարկումը։
Արդեն միայն այս հատկությունները թույլ են տալիս Unison-ին դուրս գալ այն սահմաններից, որ առաջարկում են այսօրվա հիմնական լեզուները՝ առանց ջանքի վերանվանման ռեֆակտորինգներ, կախվածությունների «դժոխքի» բացակայություն և էֆեկտավոր հաշվարկները սահմանափակելու հնարավորություն՝ առանց ընթեռնելիությունը վնասելու, թվարկենք միայն մի քանիսը։ Unison-ը գնում է այլ ճանապարհով և միևնույն ժամանակ առաջին տեղում է դնում «ծրագրավորողի փորձառությունը», ինչը այն դարձնում է հետաքրքիր ուսումնասիրության առարկա։
Սակայն Unison-ը ևս մեկ հնարք ունի թևի տակ՝ Unison Cloud։ Այն բաց կոդով չէ և հասանելի է միայն փակ բետա-թեստավորման շրջանակում, բայց վերը նկարագրված հատկությունների շնորհիվ կարող է բաշխված ծրագրավորումը դարձնել այսօրվա համեմատ շատ ավելի մատչելի՝ և իսկապես հաճելի գրելու համար։
Սա դեռ ամենը չէ. կարելի է սպասել նաև արտադրողականության աճի՝ «հաշվարկը տանել տվյալների մոտ» մոդելի շնորհիվ, ի հակադրություն պրակտիկայում տարածված «տվյալները բերել հաշվարկի մոտ» մոտեցման։
Գուցե սա այն ամպն է, որ մեզ խոստացել էին։
Հեռակա կատարում
Unison-ում բաշխված, և ընդհանրապես ցանցային, հաշվարկների աջակցությունը բաղկացած է երեք մասից։ Առաջինը օգտատերերին տրամադրվող ծրագրավորման ինտերֆեյսն է, որը գտնվում է distributed անվանատարածքում։ Դրա կենտրոնական աբստրակցիան Remote ability-ն է, որը թույլ է տալիս հաշվարկներ գործարկել հեռավոր հանգույցներում և սպասել դրանց արդյունքներին։
Երկրորդ մասը Unison Cloud-ի կլիենտն է. բացի ամպային ծառայությանը հասանելիության կարգավորումից, այն առաջարկում է run ֆունկցիան։ Այս ֆունկցիան մշակում է Remote ability-ն՝ մեկնաբանելով այն որպես IO + Exception, որոնք հետո կարելի է մշակել տեղում․
run : '{Remote, Http, Atomic, Channels, Scratch} a ->{IO, Exception} a
Վերջին մասը Unison Cloud-ի սերվերային իրականացումն է՝ ժամանակի բաշխումը, հաղորդակցությունը, կլաստերի վիճակի հետևումը և այլն։ Թե՛ կլիենտը, թե՛ սերվերը ներառում են սերիալիզացիայի և ցանցային աշխատանքի տրամաբանությունը՝ բոլոր այն ձանձրալի, բայց կարևոր բաները, որոնց մասին չէիք ցանկանա մտածել։ Սերվերը այն է, ինչ դեռ չենք կարող օգտագործել, բայց կարող ենք հայացք գցել, թե ինչ է սպասվում։
Երբ Unison-ում բաշխված համակարգեր եք գրում, ամենատարրական գործողությունը, որի հետ գործ կունենաք, հաշվարկի ճյուղավորումն է (fork), որպեսզի այն կատարվի հեռավոր հանգույցում, forkAt-ի միջոցով․
forkAt : Location g -> '{g, Remote, Exception} t ->{Remote} Task t
Ֆունկցիան ընդունում է Location՝ մեկ սերվերի կամ սերվերների խմբի (տարածաշրջանի) վերացական նկարագրություն։ Հենց այստեղ էլ ի վերջո կկատարվի հաշվարկը։
Երկրորդ արգումենտը հենց հաշվարկն է։ Այն հեռավոր հանգույց է փոխանցվում այն նույն մեխանիզմով, որին արդեն հանդիպել ենք. երբ գրադարանը fork ենք անում Unison Share-ի միջոցով, Unison-ի կոդը ճանապարհորդում է ցանցով։ Գործընթացը հիմնված է ֆունկցիաների հեշերի և, ավելի լայն առումով, բովանդակությամբ հասցեավորվող կոդի գաղափարի վրա։
Հեռավոր հանգույցը պետք է ձեռք բերի այն ֆունկցիան, որի հեշը համընկնում է forkAt-ին որպես արգումենտ փոխանցվածի հետ, իր բոլոր կախվածությունների հետ միասին (կրկին՝ ճիշտ ինչպես fork անելիս)։ Դա կարող է պահանջել մի քանի ցանցային փոխանակում, քանի որ թիրախ սերվերը կարող է արդեն ունենալ կոդի ամբողջ գրաֆը տեղում, կամ միայն դրա մի մասը։
Հաշվարկն ինքը կարող է օգտագործել Remote ability-ն (այլ հանգույցների հետ խոսելու համար), բացառություններ նետել և օգտագործել այն ability-ները, որոնք աջակցում է տեղակայությունը (դրան կանդրադառնանք հետո)։ Այս ամենն արտահայտվում է '{g, Remote, Exception} t տիպով։ ' մեջբերումը այստեղ էական է. այն նշում է ծույլ հաշվարկվող կոդի հատված, որը դեսուգարից հետո պարզապես () ->{g, Remote, Exception} t thunk է։
Նկատեք նաև, որ կոնֆլիկտներ, evict-ի սխալներ կամ անունների բախումներ չեն կարող առաջանալ, քանի որ ամեն ինչ աշխատում է հեշերի մակարդակում։ Մեկ վերահսկիչը (supervisor) կարող է կատարել կոդ, որը հենվում է Unison-ի base գրադարանի տարբեր տարբերակների վրա՝ առանց դրան ուշադրություն դարձնելու։
Task, բայց ոչ մոնադ
forkAt-ը կանչելով՝ մենք ստանում ենք հաշվարկ, որն օգտագործում է Remote ability-ն և վերադարձնում է Task՝ ինչ-որ հանգույցում (հեռավոր կամ տեղային) ընթացող հաշվարկի ներկայացում։
Task-ը կարող է հիշեցնել այլ լեզուների Future կամ Promise։ Որոշ առումներով դա ճիշտ է։ Օրինակ՝ Remote.empty!-ով կարելի է ստեղծել նոր task, որը հետագայում կարելի է ավարտել կամ արժեքով, կամ սխալով՝ Remote.tryComplete-ի միջոցով։
Սակայն քանի որ Unison-ը տրամադրում է թեթև թելեր և ուղիղ ոճով ծրագրավորում (այլ ոչ թե մոնադիկ ոճ), այստեղ չեք գտնի flatMap-եր կամ մի քանի task-եր շղթայելու այլ գործողություններ։ Փոխարենը դուք await եք անում task-ը, և երբ դրա արդյունքը հասանելի է, օգտագործում եք այն հաջորդ արժեքը հաշվելու համար․
await : Task a ->{Remote} a
Որտե՞ղ է իմ task-ը
Unison-ում բաշխված ծրագրավորման հիմնական հատկություններից մեկն այն է, որ հաշվարկները որտեղ կատարվելու մասին ճշգրիտ վերահսկողություն կա։ Եվ թեև ընդհանուր գաղափարը «հաշվարկը տանել տվյալների մոտ» է, այլ ոչ թե «տվյալները բերել հաշվարկի մոտ», (քիչ ջանքով) դեռ հնարավոր է ամեն ինչ անել ավելի անարդյունավետ, քան կարելի էր։
Դիտարկենք մի պարզ օրինակ, որը վերցված է անմիջապես distributed անվանատարածքի ներածական փաստաթղթերից․
example1 loc =
t1 = forkAt loc '(1 + 1)
t2 = forkAt loc '(2 + 2)
await t1 + await t2
Այս կոդը տրված loc տեղակայությունում գործարկում է երկու հաշվարկ (հավանաբար զուգահեռաբար), ապա երկու արդյունքների համար էլ await է անում։ Հիշեք, որ await-ը տեղի է ունենում տեղում՝ այսինքն այն հանգույցում, որը կատարում է example1 ֆունկցիան։ Հետևաբար t1 և t2 task-երի արդյունքները հեռավոր loc-ից ուղարկվում են կանչող տեղակայություն։ Այս դեպքում տվյալները և արդյունքների ռեդուկցիան (+) աննշան են, ուստի դա կարևոր չէ, բայց ընդհանուր դեպքում կարող է խնդիր դառնալ։
Ահա մի փոքր փոփոխված օրինակ, որն փորձում է նվազեցնել հանգույցների միջև փոխանցվող տվյալների քանակը․
example2 loc =
use Nat +
t1 = forkAt loc '(1 + 1)
t2 = forkAt loc '(2 + 2)
t3 = forkAt (task.location t1) '(await t1 + await t2)
await t3
Կարող եք հարցնել, թե ինչու է t3-ը fork արվում task.location t1-ում՝ այսինքն այնտեղ, որտեղ աշխատել է t1-ը, այլ ոչ թե պարզապես loc-ում։ loc-ը կարող է նշանակել լայն տարածաշրջան, որտեղ հաշվարկները կարելի է fork անել, այլ ոչ թե որևէ կոնկրետ հանգույց։ Այդ դեպքում մենք ապահովում ենք, որ t3-ը գոնե աշխատի նույն հանգույցում, ինչ t1-ը։ Իսկ t2-ը կարող է հայտնվել մեկ այլ հանգույցում։ Ամեն դեպքում, հանգույցների միջև ավելի քիչ տվյալներ են ճանապարհորդում։
Ամբողջը այն մասին է, ինչ այնտեղ չկա
Այստեղ ոչ մի կախարդանք չկա. թե հաշվարկի ո՛ր մասը որտեղ է աշխատում և արդյունքները ինչպես են համակցվում, կարող է լինել բաշխված ծրագրավորման ոլորտի էական բարդությունը, բայց հեշտ է չնկատել, թե ինչն է բացակայում վերը բերված կոդի հատվածներից։
Նայեք. հեռավոր հանգույցում ֆունկցիա գործարկելու համար մենք այն պարզապես տվեցինք forkAt-ին։ Իսկ արդյունքը ստանալու համար պարզապես կանչեցինք await։ Ոչ մի սերիալիզացիա, JSON-ի և Protobuf-ի միջև ոչ մի դժվար ընտրություն (դրանք արվում են մեր փոխարեն), միացումների ոչ մի կարգավորում և այլն։ Այդուհանդերձ, հեռավոր կանչը մնում է տեղայինից տարբեր, քանի որ պահանջում է Remote ability-ն։ Ահա թե ինչու մենք չենք ընկնում RPC-ի մոլորության մեջ։ Այնուամենայնիվ, հավանաբար սա այնքան մոտ է, որքան հնարավոր է հասնել՝ հեռավոր կանչը տեղայինի պես աշխատեցնելով և մնալով անվտանգ։ Պատահական բարդության մեծ մասը (գուցե ամբողջը) անհետացել է։
Կարող եմ կռահել, թե ինչ եք մտածում. սխալներ կարող են առաջանալ, բայց դրանց հետ կարելի է պատշաճ կերպով գործ ունենալ։ Իսկապես, կրկնակի փորձերը (retries) կարելի է ավելացնել Remote-ի համար ability handler-ի միջոցով, որը ստեղծում է մեկ այլ Remote հաշվարկ (այս անգամ՝ ցանցային կրկնակի փորձերը միացված, տես Remote.retrying)։ Նույն ձևով կարելի է ներմուծել timeout-ներ, bulkheading, circuit breaker-ներ և այլն։
Եվ հաշվի առեք սա. rolling upgrade-ը հանգում է արտաքին աշխարհին բաց ծառայության մեջ ֆունկցիայի նոր հեշ օգտագործելուն. մեր սերվերային ֆերմաներում երկուական ֆայլեր վերատեղակայելու կարիք չկա։ Unison-ը առաջին կանչի ժամանակ հոգում է ճիշտ հեշերի բաշխումը։ Այդ ընթացքում արդեն աշխատողները շարունակում են առանց փոփոխության։
Spark-ի նման տվյալների բազմություններ
Remote-ի և Task-ի վրա Unison-ը տրամադրում է մի քանի բարձր մակարդակի կառուցվածքներ։ Դրանցից մեկը Seq-ն է՝ ծույլ հաշվարկվող, բաշխված տվյալների կառուցվածք։ Այն կարող է մոդելավորել բազմաթիվ հանգույցներում տարածված տվյալների բազմություններ, որտեղ տվյալների ընդհանուր չափը մեծ է ցանկացած առանձին հանգույցի հիշողությունից։
Բլոգային գրառումների մի հիանալի շարք բացատրում է, թե ինչպես է նախագծվել այս տվյալների կառուցվածքը, այնպես որ ես պարզապես խորհուրդ կտամ կարդալ այն։
Սահմանափակված տեղակայություններ
Արժե ընդգծել, որ տեղակայությունները նույնը չեն։ Փոխարենը յուրաքանչյուրը պարամետրացվում է այն ability-ներով, որոնք հասանելի են այդ տեղակայությունում կատարվող կոդին։
Օրինակ՝ ներկայիս (փակ բետա) Unison Cloud-ում հաշվարկները կարելի է գործարկել այս ability-ներով․
{Remote, Http, Atomic, Channels, Scratch}
Գործնականում դա նշանակում է, օրինակ, որ կամայական մուտք/ելքը բացառվում է, քանի որ IO ability-ն ներառված չէ։ Սակայն կարող ենք խոսել ամպի այլ հանգույցների հետ, կատարել HTTP հարցումներ, հիշողության մեջ պահել փոփոխվող վիճակ, հաղորդագրություններ փոխանակել channel-ների միջոցով և հարցումները memoize անել քեշում։
Այս ability-ները թույլ են տալիս շատ բան անել, մինչդեռ հարթակը կարող է երաշխավորել իր կատարած ֆունկցիաների անվտանգությունն ու լիակատար մեկուսացումը։
Բնականաբար, այլ տեղակայություններ կարող են հասանելիություն տալ ability-ների այլ հավաքածուի։ Դրանք կարող են ավելի շատ հնարավորություններ տալ, բայց հնարավոր է՝ լրացուցիչ գնով։
Unison-ի համակարգիչը
Այս ամենը միասին վերցրած՝ Unison Cloud-ի տեղակայման հանգույցները գործում են որպես մեկ մեծ համակարգիչ։ Չափազանց լավ է հնչում՝ իրական լինելու համար։ Մեծ մասամբ՝ այո։ Unison-ը գոյություն ունի միայն որպես փակ բետա, և ինչպես բոլորը գիտեն, սատանան մանրուքների մեջ է։
Unison-ում բաշխված ծրագրեր գրելը նրբագեղ է և բարեկամական ծրագրավորողների համար. հենց այն հաշվարկն է, որով կցանկանայիք զբաղվել։ Սակայն ուշ թե շուտ ձեզ հարկ կլինի ինտեգրվել արտաքին աշխարհի հետ։ Իսկ այդ բոլոր ինտեգրացիաները տեղում դնելը շատ աշխատանք կպահանջի։
Կարևոր մի կետ, որ պետք է հիշել. Unison-ը փակ, պատերով շրջապատված համակարգ է։ Նրա նրբագեղության մի մասը գալիս է նրանից, որ ամեն ինչ գրված է Unison-ով, և դա նաև թուլություն է, քանի որ ամեն ինչ պետք է գրված լինի Unison-ով։ Ուստի ձեր սիրած ամեն օգտակար գրադարան կպահանջի Unison-ի համարժեք։
Այդուհանդերձ, Unison-ը կարող է պատրաստ լինել այդ խնդրին։ Ի վերջո անհրաժեշտ կլինի Foreign Function Interface (FFI), որպեսզի կարողանանք, օրինակ, կանչել հանգույցում տեղային պահվող տվյալների վրա նատիվ թվային ալգորիթմ։ Սեփական handler ունեցող ability-ն այդպիսի ինտեգրացիայի համար կատարյալ տարբերակ է։
Ամպը եզրում
«Ամպից» բացի կա ևս մեկ միտում՝ edge computing։ Գաղափարն այն է, որ հաշվարկները տեղափոխվեն օգտատիրոջ մոտ՝ կամ նրա սեփական սարքի վրա (օրինակ՝ սմարթֆոն), կամ նրա շրջակայքում ինչ-որ տեղ (օրինակ՝ բջջային կապի բազային կայան կամ բովանդակության առաքման ցանցին պատկանող edge սերվեր)։ Եթե edge computing-ը ձեզ հետաքրքրում է, հավանաբար հանդիպել եք «հաշվարկը տանել տվյալների մոտ» արտահայտությանը՝ հենց այն հայեցակարգը, որն իրականացնում է Unison Cloud-ը։
Սա պատահական չէ. Unison-ը և նրա մոդելը հատկապես լավ են համապատասխանում այս դեպքին։ Հաշվարկները եզր առաքելը հեշտ է. դա կրկին նույն մեխանիզմն է, և պահանջվում է միայն կատարվելիք ֆունկցիայի հեշը և մի քանի peer, որոնցից այդ ֆունկցիան կարելի է բեռնել։ Ավելին, Unison-ի հաշվարկները աշխատում են sandbox-ում։ Դա նման է այն բանին, ինչ տալիս է WebAssembly-ն, որտեղ այն համարվում է անվտանգության առանցքային առանձնահատկություն։
Sandbox-ը կառուցված է Unison-ի ability-ների վրա։ Ասենք՝ հայտարարում ենք, որ տվյալ edge տեղակայությունը կարող է կատարել միայն որոշակի ability-ներ օգտագործող ֆունկցիաներ։ Այդ դեպքում կարող ենք վստահ լինել, որ ոչ մի այլ գործողություն չի կատարվի (պայմանով, որ Unison լեզուն չի բացահայտում անվտանգ չլինող «հետնադռներ», ինչը մինչ այժմ այդպես է)։
Ամենակարևորը՝ ամբողջ գործընթացը շատ թեթև է և անտեսանելի ծրագրավորողի համար։ Ուղարկվում է միայն տվյալ ֆունկցիան գործարկելու համար անհրաժեշտ կոդը (հեշերը)՝ հենց այդքանը, ոչ ավելի, ոչ պակաս։ Դրանից բացի՝ ստանում ենք ֆունկցիոնալ, աղբահավաքով ծրագրավորման լեզու էֆեկտավոր հաշվարկների ուղիղ շարահյուսությամբ։ Սա խոստումնալից է թվում։
Ի՞նչ է հաջորդը
Սրանով մեր Unison մինի-շարքն ավարտվում է։ Մինչև Unison Cloud-ի բաց բետայի հայտնվելը, կարող եմ միայն խորհուրդ տալ ծանոթանալ լեզվին նրա մեկ հանգույցանի տարբերակով։ Ինձ համար դա միանշանակ շատ ուսուցողական և ոգեշնչող փորձառություն էր։
Ես անհամբեր սպասում եմ Unison-ի ավելի մեծ թափ հավաքելուն և հուսով եմ՝ երբևէ կգրեմ բաց կոդով Unison-ի կոդ։