Ինչ կցանկանայի իմանալ Event Sourcing-ով սկսելիս – մաս 1
Այս շարքը ներկայացնում է այն, ինչ ես սովորել եմ առայժմ՝ հայտնագործությունները, գիտակցումներն ու անակնկալները, որոնց հանդիպել եմ Event Sourcing-ի հետ աշխատելու տարիների ընթացքում։
Վերջին մի քանի տարիներին բախտ եմ ունեցել սովորելու և աշխատելու event sourcing-ով ստեղծված բազմաթիվ սերվիսների հետ։ Խոստովանեմ, որ երբեմն մեր հարաբերությունները թեքվում էին «սիրել-ատել» զույգի «ատելու» կողմը, իսկ երբեմն event sourcing-ը օգտագործվում էր չափից շատ, կամ գոնե այնտեղ, որտեղ դա անհրաժեշտ չէր։
Հետ նայելով այդ բոլոր տարիներին՝ այն համարում եմ իսկապես հզոր, գործնական և ակնհայտորեն թերագնահատված գործիք ինժեների գործիքակազմում։ Այդուհանդերձ, դա ընդամենը մեկ այլ մոտեցում է, որը նախատեսված է մեր ինժեներական աշխատանքի բավականին նեղ հատվածներին օգնելու համար, այլ ոչ թե «արծաթե գնդակ», որը խոստանում է լուծել մեր նախագծերի բոլոր խնդիրներն ու մարտահրավերները։
Այս նոր շարքում ցանկանում եմ ներկայացնել իմ քաղած դասերը, ինչպես նաև այն հայտնագործություններն, գիտակցումներն ու անակնկալները, որոնց հանդիպել եմ իմ ստեղծած համակարգերում event sourcing-ը կիրառելու այդ տարիների ընթացքում։ Այս հոդվածը ներառում է տեխնիկայի մի քանի հիմնական ուժեղ կողմեր և այն, թե ինչպես եմ սովորել գնահատել դրանք։ Հետագայում ավելի շատ կգրեմ մարտահրավերների և մի քանի թակարդների մասին, որոնց հանդիպել եմ։ Այսպիսով՝ սկսենք։
Ժամանակով ճամփորդելու գերուժ
Սկսենք event sourcing-ի հավանաբար ամենաակնհայտ և ամենաճանաչված հատկությունից, որը սովորաբար գլխավոր փաստարկն է յուրաքանչյուրի համար, ով փորձում է այն «վաճառել»։
Ժամանակով ճամփորդելու իրական արժեքը պարզ է դառնում միայն այն ժամանակ, երբ անհրաժեշտ է հետևել և խորանալ մի սխալի մեջ, որը ինչ-որ կերպ ներթափանցել է production։ Հանկարծ ձեր սերվիսը որոշ օգտատերերի համար սկսում է խափանվել. կամ նրանք չեն կարողանում հասանելի դարձնել որևէ ֆունկցիա, կամ այն ցույց է տալիս անիմաստ տվյալներ։
Դուք դնում եք դետեկտիվի գլխարկը և սկսում եք բոլոր մետրիկաների և համակարգի առողջության ստուգումներից՝ ամեն ինչ նորմալ է թվում։ Հետո արագ հայացք եք գցում վերջին լոգերին, բայց կրկին կասկածելի ոչինչ չկա, բացի հաղորդագրություններից, որ այս ֆունկցիայի հետ կապված ինչ-որ բան այն չէ որոշակի օգտատիրոջ համար։
«Ավանդական» համակարգերում, որտեղ պահպանումը հիմնված է վիճակի snapshot-ների վրա, ձեր հաջորդ քայլը հավանաբար նման է SELECT * FROM accounts WHERE user_id = 123-ի՝ տեսնելու համար, թե ինչ կա այնտեղ, հույս ունենալով պատասխանի, որը կլինի «Օ, վիճակը սխալ է»։ Գուցե անմիջապես տեսնում եք խնդիրը և գիտեք, թե ինչպես այն շտկել UPDATE accounts SET … WHERE user_id = 123-ով, բայց ի՞նչ, եթե չգիտեք։ Ինչպե՞ս պարզել, թե ինչու, ինչպես և երբ է էությունը հայտնվել այս սխալ վիճակում։
Ձեր ունեցածը միայն ընթացիկ վիճակի snapshot-ն է և, հնարավոր է, եթե բախտը բերի (և լոգավորման հարցում մի փոքր պարանոյիկ լինեք, ինչպես ես), հին լոգերի կույտ։ Սակայն երբեմն դա բավարար չէ. դուք աշխատում եք կուրորեն, և հենց այստեղ է հետաքննությունը դժվարանում։ Դա չի նշանակում, որ հնարավոր չէ. մենք բոլորս եղել ենք այդ իրավիճակում, և սովորաբար լինում է շտկելու միջոց, պարզապես բոլոր կետերը կապելը կարող է մի փոքր ավելի դժվար լինել։
Եթե, սակայն, ձեր վիճակի պահպանումը հիմնված է event sourcing-ի վրա, դուք հանկարծ ստանում եք շատ ավելի համատեքստ և տվյալներ՝ աշխատելու համար։ Դուք ունեք բոլոր փաստերը, որ պատահել են էության հետ ժամանակի ընթացքում, այն փաստերը, որոնք առաջացրել են նրա վիճակի բոլոր փոփոխությունները, ժամանակագրական կարգով և բոլոր մանրամասներով։
Այնուհետև կարող եք սկսել ճամփորդել ժամանակի մեջ հետ. վերարտադրել իրադարձությունները մեկ առ մեկ մինչև ընտրված պահը (օրինակ՝ 2 շաբաթ առաջ) և նայել, թե ինչ վիճակում էր էությունն այդ պահին։ Ճի՞շտ է թվում։ Ապա վերարտադրեք էլի մի քանիսը, մինչև հասնեք սխալ վիճակին։ Սա արդեն սխա՞լ է։ Քայլ հետ արեք և գտեք այն իրադարձությունը (կամ իրադարձությունները), որը պատասխանատու է փչացած վիճակի համար։
Մի քանի նախորդող և հաջորդող իրադարձությունների հետ համատեղ այս հաջորդականությունը թույլ է տալիս վերակառուցել ամբողջ պատմությունը՝ ինչ է պատահել և ինչու։ Շնորհավորում եմ։ Այժմ դուք ավելի լայն պատկերացում ունեք, թե ինչն է ամենայն հավանականությամբ առաջացրել խնդիրը։ Կոդի այն հատվածի շտկումը, որտեղ ձեր տրամաբանությունը սխալվում է (գուցե չաջակցվող եզրային դեպք՞), այժմ պետք է լինի բավականին պարզ։
Հոլիվուդյան սցենարի պես է հնչում, այնպես չէ՞։ Բայց ամեն ինչ այդքան վարդագույն չէ, և պատկերը լրացնելու համար կան մի քանի բաներ, որոնց մասին դեռ չեմ խոսել։ Ինչպե՞ս հենց ճամփորդել ժամանակի մեջ production տվյալների վրա։ Ինչպե՞ս նայել միջանկյալ վիճակներին, երբ ձեր ունեցածը իրադարձությունների հաջորդականություն է, երբեմն պահված երկուական, այլ ոչ թե մարդու համար ընթեռնելի ձևով (այս մասին՝ շարքի հաջորդ մասերում)։ Եվ վերջապես, ինչպե՞ս շտկել սխալը այն օգտատերերի համար, ովքեր արդեն տուժել են. վերագրե՞լ անցյալը։ Եկեք այս հարցերը քննարկենք մեկ առ մեկ։
Ներդրեք ձեր նախագծի գործիքակազմում և ստեղծեք այն
Event sourcing-ում չկա «պահպանված» կամ «նյութականացված» վիճակի հասկացություն, ուրեմն ինչպե՞ս ստուգել վիճակը հաջորդականության յուրաքանչյուր իրադարձությունից հետո՝ խնդիրը հետազոտելիս։
Ըստ էության, դուք կրկնում եք այն նույն ընթացակարգը, որով անցնում է ձեր էությունը, երբ վերարտադրում է իր իրադարձությունների հոսքը՝ հրամանը մշակելու համար։ Տարբերությունն այն է, որ էությունը վերարտադրում է յուրաքանչյուր իրադարձություն սկզբից մինչև վերջ՝ հրամանի մշակման համար վերջին վիճակին հասնելու նպատակով, մինչդեռ դուք ուզում եք կանգ առնել ավելի շուտ՝ որոշակի իրադարձությունից առաջ կամ հետո, տվյալ timestamp-ից առաջ կամ հենց հետո և այլն։
Այսպիսի devtool-ը սովորաբար առաջին բանն է, որ գրում եմ event-sourced սերվիսների վրա աշխատելիս, ինչպես նաև առաջիններից մեկը, որին դիմում եմ նման խնդիրները հետազոտելիս։ Սովորաբար դա command-line գործիք է կամ հեշտ գործարկվող ինչ-որ ծրագիր, որը գտնվում է իմ production կոդի կողքին, որպեսզի կարողանամ իրադարձությունները վերարտադրել ճիշտ այնպես, ինչպես իմ production էություններն են անում՝ միայն սահմանափակելով, թե որ իրադարձություններն են մատակարարվում։ Այն գործարկում եմ production տվյալների վրա՝ կա՛մ տվյալ էության իրադարձությունների հոսքի dump-ը բեռնելով լոկալ տվյալների բազա, կա՛մ, եթե հնարավոր է, միանալով read-only production տվյալների բազային։ Այն ընդունում է սխալ էության id-ն և կա՛մ իրադարձության հերթական համարը, կա՛մ timestamp, որով պետք է վերարտադրվի հոսքը, և հենվում է production էությունների նույն կոդի վրա՝ իրադարձությունները բերելու, վերծանելու և կիրառելու համար։ Երբ հասնում է սահմանին, պարզապես տպում է էության ընթացիկ վիճակը կոնսոլում։ Երբեմն ավելացնում եմ լրացուցիչ հնարավորություն. որոշակի իրադարձության հասնելուց հետո հոսքի յուրաքանչյուր հաջորդ իրադարձություն կիրառվում է միայն «ստեղնի սեղմումով», և վիճակը տպվում է յուրաքանչյուրից հետո։ Դա նման է ձեր էությունների համար սեփական փոքրիկ debugger ստեղծելուն։
Նույնիսկ երբ ձեր իրադարձությունները պահվում են երկուական ձևաչափով, իրական event handler մեխանիզմի օգտագործումը նշանակում է, որ ձեզ պետք չէ դա բացահայտ կերպով մշակել կամ դրանք ձեռքով նորից վերծանել։ Նման գործիքի շնորհիվ ժամանակով ճամփորդելը դառնում է հեշտ. դուք կարող եք ճշգրիտ տեսնել, թե ինչ վիճակում էր էությունը, օրինակ, 2 շաբաթ առաջ, և ինչպես է յուրաքանչյուր իրադարձություն փոխել այն։ Այն միայն կարդում է տվյալների բազայի գրառումների մի շարք, և իրադարձությունների կիրառումը չի առաջացնում կողմնակի ազդեցություններ, ուստի կարող եք անել այնքան փորձ, որքան անհրաժեշտ է սխալ իրադարձությունը գտնելու համար։
Ժամանակի ընթացքում նախագծի dev գործիքակազմը սովորաբար շարունակում է աճել, և կառուցվում են կոնկրետ, ad-hoc view-ներ/projection-ներ՝ հաճախակի հարցերին արագ պատասխանելու համար։ Էությունների շուրջ հայտնվում են լրացուցիչ գործիքներ, որոնք հեշտացնում են ամենօրյա աշխատանքը, մասնավորապես՝ խնդիրների հետազոտումը, բայց ժամանակի մեջ ճամփորդելու և իրադարձությունների հոսքերը debug անելու գործիքը սովորաբար առաջինն եմ ստեղծում։
Անցյալի ուղղումը
Երբ խնդիրը հայտնաբերված է, ժամանակն է շտկել այն։ Դուք գիտեք ընթացակարգը՝ փոխել կոդը, գրել և գործարկել թեստերի շարք, սպասել CI pipeline-ի ավարտին և ուղարկել այն։ Բայց դա միայն աշխատանքի կեսն է։ Այն, ինչ այժմ ունեք, ճիշտ վարքագիծ է այս պահից համակարգ ժամանող հրամանների և դրանց արդյունքում ստեղծվող նոր իրադարձությունների համար։
Իսկ ինչ վերաբերում է այն էություններին, որոնց վրա սխալն արդեն ազդել է և որոնց հոսքերը պարունակում են այս սխալ կամ պարզապես սխալ իրադարձությունները։ Դուք այլևս չեք կարող պարզապես գործարկել UPDATE հայտարարություն տվյալների բազայի որոշ տողերի վրա, քանի որ իրական վիճակ գոյություն չունի։ Հիշեք, որ անցյալը չի կարելի փոխել. իրադարձությունները անփոփոխ փաստեր են, որոնք չպետք է փոփոխեք։
Բայց ինչո՞ւ է այդպես, իրականում։ Առաջին հայացքից դա թվում է խելամիտ մոտեցում. event store-ում սխալ իրադարձությունը փոխարինեք ճիշտով, և վերջ։ Նախ, եթե դա անում եք, պետք է համոզվեք, որ իրադարձության նոր տարբերակը իսկապես կարող է ճիշտ կիրառվել համապատասխան վիճակի վրա, այսինքն՝ որ իրադարձությունը տրամաբանորեն իմաստ ունի հաջորդականության մեջ։ Բայց դա ավելի հեշտ մասն է, և սովորաբար կարելի է ստուգել։ Ավելի քիչ ակնհայտ և սովորաբար անտեսանելի թակարդն այն է, թե որքան «տեղային» է նման ձեռքով միջամտությունը։
Բացի write կողմից, event-sourced համակարգերը ներառում են նաև այսպես կոչված read կողմեր՝ կոդի հատվածներ, որոնք սպառում են ձեր էությունների գրած իրադարձությունների հոսքերը և գործում են դրանց հիման վրա։ Դրանց գործողությունները կարող են տարբեր լինել՝ տվյալների view-ների/projection-ների ստեղծումից (օրինակ՝ հաշվետվություններ, գրաֆիկներ և այլն), մինչև արտաքին, մասնագիտացված տվյալների բազաներում հատուկ read model-ների կառուցումը, որոնք անհրաժեշտ են քիչ թե շատ կարևոր բիզնես որոշումների համար, և սովորական event handler-ներ, որոնք բացահայտ կանչում են այլ սերվիսներ կամ հաղորդագրություններ («հանրային իրադարձություններ») հրապարակում հերթերում, որոնք վարում են համակարգի այլ մասերը։
Յուրաքանչյուր ներքևի (downstream) բաղադրիչ կախված է նրանից, որ ձեր իրադարձությունների հոսքերը տրամաբանորեն համահունչ են, և երաշխիքից, որ պահպանված իրադարձությունը մնում է այնտեղ ընդմիշտ՝ անփոփոխ։ Սա նշանակում է, որ յուրաքանչյուր հաշվետվություն և read model արդեն սպառել է այդ իրադարձությունը և կիրառել այն իր կողմում (հավանաբար՝ սխալ թվեր ստանալով, ինչը գուցե հենց այն եղանակն է, որով հայտնաբերել եք սկզբնական խնդիրը)։ Յուրաքանչյուր event handler նույնպես սպառել է իրադարձությունը՝ կանչելով այլ համակարգեր կամ հաղորդագրություններ հրապարակելով դրա տվյալների հիման վրա։ Իրադարձությունը մշակելուց հետո նրանք առաջ են գնում և երբեք հետ չեն նայում, ուստի նույնիսկ չեն նկատի, որ դուք ձեռքով փոխել եք հոսքի նախկին իրադարձություններից մեկը։
Թեև դուք «շտկեցիք» հենց իրադարձությունը, չշտկեցիք այն ամենը, ինչի վրա սխալ իրադարձությունը ազդել է։ Իհարկե, կարող եք փորձել ձեռքով փոփոխել կամ վերակառուցել ձեր read model-ները և նորից գործարկել այլ սերվիսների կանչերը ճիշտ payload-ներով, բայց վստա՞հ եք, որ գիտեք և վերահսկում եք ձեր իրադարձությունների յուրաքանչյուր downstream սպառողին։ Իսկ ինչ վերաբերում է տվյալների համահունչությանը աուդիտի դեպքում։
Event sourcing-ի և նրա իրադարձությունների մատյանի ևս մեկ մեծ վաճառքի կետը հեշտ աուդիտելիությունն է, որը գործնականում ստացվում է անվճար։ Իսկ եթե աշխատում եք խիստ կարգավորվող միջավայրում կամ պարզապես պարբերաբար աուդիտի եք ենթարկվում։ Ձեռքով մտցված նման անհամապատասխանությունները վաղ թե ուշ կբացահայտվեն աուդիտի ժամանակ, և դուք կբախվեք բավականին տհաճ հետևանքների։ Անցյալ իրադարձությունների փոփոխության թույլտվությունը ոչնչացնում է ցանկացած վստահություն, որ աուդիտորը կարող է ունենալ event store-ի նկատմամբ։ Անփոփոխելիությունը խիստ պահանջ է ցանկացած մատյանային տվյալների համար, հատկապես երբ դրանք պետք է համապատասխանեն կանոնակարգումներին։
Սխալ չհասկանաք ինձ. իրադարձությունների վերագրումը լիովին արգելված չէ։ Կան սերվիսներ և իրավիճակներ, որտեղ դա միանգամայն ընդունելի է. ընդամենը մի քանի downstream սպառողներ, որոնք դուք լիովին վերահսկում եք և որոնք հեշտ է ուղղել, ինչպես read model-ները. համակարգը «կարգավորվող» չէ և այլն։ Ես ինքս մի քանի անգամ արել եմ դա. պատմության հետ գործ ունենալը բավականին սթրեսային է, բայց այդ դեպքերից յուրաքանչյուրում ամեն ինչ լավ է անցել։
Այդուհանդերձ, նման խնդիրները լուծելու ճիշտ և ամենաէլեգանտ եղանակը ուղղումը բացահայտ դարձնելն է։ Գործնականում դա նշանակում է ուղարկել բուժող/փոխհատուցող հրաման տուժած էությանը, որն այնուհետև պահպանում է փոխհատուցող իրադարձություն, որը շտկում է նախկին վիճակի հետ կապված ցանկացած սխալ։
Իրադարձության payload-ը կարող է պարունակել ցանկացած անհրաժեշտ բան՝ ուղղող արժեքներ, ուղղվող իրադարձության/գործողության հղում. դա ձեր որոշումն է։ Իհարկե, կարող եք դա անվանել գերճարտարագիտություն, քանի որ սովորաբար ժամանակ է պահանջում և նոր կոդ (երբեմն՝ կոդ, որը կգործարկեք միայն մեկ անգամ), բայց, դե, ամեն ինչ փոխզիջումների մասին է։ Տեսնենք, թե ինչ եք ստանում դրա դիմաց։
Այս նոր տեսակի բուժող/փոխհատուցող իրադարձության հրապարակումը, առաջին հերթին, ուղղումը դարձնում է բացահայտ. իրադարձությունը երկարաժամկետ գրանցվում է իրադարձությունների հոսքում, ուստի աուդիտի ժամանակ անհամապատասխանությունների ռիսկ այլևս չկա և այլն։
Արդյունքում դուք ինչ-որ իմաստով «ստիպում եք» յուրաքանչյուր read model-ի և event handler-ի բացահայտորեն մշակել այս նոր իրադարձությունը։ Նրանք, իհարկե, կարող են որոշել անտեսել այն, բայց գոնե պետք է ընդունեն դրա ստացումը։ Նրանք կարող են արձագանքել, օրինակ, իրենց հաշվետվություններում թվերը ուղղելով կամ ուղղված հաղորդագրություններ ուղարկելով ներքև. դա նրանց որոշումն է։
Դուք ձեր ուղղիչ որոշումը դարձրել եք բացահայտ՝ գրանցելով փաստ էության մասին, և յուրաքանչյուր ոք, ով հետաքրքրված է այդ էության վիճակի փոփոխություններով, պետք է ընտրեր դրան արձագանքելու համապատասխան եղանակը (իր սեփական համատեքստում)։
Որպես այլընտրանք, ձեր էության տրամաբանությունը կարող է լիովին ճիշտ լինել, և այն սխալը, որի հետ բախվում եք, կարող է գոյություն ունենալ միայն read կողմում, օրինակ՝ որոշ հաշվետվություններ տալիս են սխալ տվյալներ, որոշ view-ներ չեն ցույց տալիս այն, ինչ պետք է և այլն։ Դրանց ուղղումը սովորաբար բավականին հեշտ է և անվտանգ (անտեսելով հենց փոփոխությունը պարզելու բնածին դժվարությունը)։
Հիշեք, որ ձեր իրադարձությունների հոսքերը ճշմարտության միակ աղբյուրն են, ուստի կարող եք վերակառուցել վիճակը ցանկացած պահի՝ պարզապես իրադարձությունները վերարտադրելով և ստացված վիճակը ուսումնասիրելով ցանկացած տեսանկյունից։ Հենց այդպես են աշխատում read model-ները. նրանք պարզապես վերարտադրում են իրադարձությունների հոսքերը և մեկնաբանում ստացվող իրադարձությունները յուրովի։
Ձեզանից պահանջվում է միայն շտկել կոտրված projection-ը (read կողմը) և թողնել, որ այն վերակառուցվի հենց սկզբից (կամ խնդրից առաջ ընկած որևէ ավելի ուշ կետից)։ Դա, իհարկե, կարող է որոշ ժամանակ տևել՝ կախված նրանից, թե քանի իրադարձություն պետք է մշակվի, և անհրաժեշտության դեպքում գուցե պետք լինի մշակել սահուն անցում, բայց էապես այսքանն է։
Քանի որ ձեր էությունները պահում են իրենց փոփոխությունների ամբողջական պատմությունը, դուք կարող եք վերարտադրել այն ցանկացած պահի՝ սկզբից կամ ժամանակի ցանկացած ընտրված կետից։
Ճարտարապետություն վաղվա հարցերի համար
Իրադարձությունների հոսքերը՝ որպես ճշմարտության աղբյուր, գործնականում հնարավոր են դարձնում «անվճար վերարտադրումներ»։ Մի պրակտիկանտ այս միտքը ամփոփել է մեկ նախադասությամբ, որին առաջին անգամ հանդիպեցի, երբ event sourcing-ի մի հայտնի ջատագով մեջբերեց այն, և ինձ համար այն արտահայտում է event sourcing-ի ամենամեծ ուժը։ Մի քանի անգամ, երբ սերվիսն արդեն որոշ ժամանակ աշխատել էր production-ում, այսպես կոչված «product թիմից» հարցում էր գալիս՝ կարո՞ղ ենք արդյոք ասել այս կամ այն բանը՝ հիմնվելով մինչ այդ պահը սերվիսի ակտիվության և գործողությունների վրա։ Սովորաբար նրանք ուզում էին տվյալների որևէ կոնկրետ տեսք, օրինակ՝ քանի, որքան, որքան հաճախ, որն է գումարը, ընդհանուրը, միջինը, տրենդը և այլն։
Առաջին հայացքից այս ամենը թվում է ստանդարտ բիզնես մետրիկաների գործ, որոնք պետք է ներդնեք ձեր համակարգում՝ անկախ նրա նախագծից։ Եվ դա բացարձակապես ճիշտ է. այդ բաներից մի քանիսը կարելի է կարդալ մետրիկաներից։ Խնդիրն այն է, որ չեք կարող կանխատեսել ապագայում ձեզ անհրաժեշտ յուրաքանչյուր մետրիկա։
Դուք կարող եք կոդ գրել միայն այն բանի համար, ինչ գիտեք հիմա։ Երաշխիք չկա, որ բիզնեսի համար կարևոր յուրաքանչյուր փոփոխություն ունի համապատասխան մետրիկա, քանի որ մետրիկաները պարզապես կողքից ավելացված կամընտիր քայլեր են, որոնք գործընթացին պետք չեն աշխատելու համար։ Event sourcing-ի դեպքում, ընդհակառակը, բիզնես հոսքի աջակցումն իր ներկա տեսքով պահանջում է պահել վիճակից վիճակ անցնելու համար անհրաժեշտ ողջ տեղեկատվությունը՝ իրադարձությունների հոսքի տեսքով։
Արդյունքում դուք պոտենցիալ գրանցում եք փոփոխությունների մասին ողջ կարևոր տեղեկատվությունը, ուստի հետագայում կարող եք այդ տվյալներին նայել բազմաթիվ տեսանկյուններից՝ կախված բիզնեսի կարիքներից։ Նույնիսկ եթե որոշ հաշվետվություններ երբեք չեն պլանավորվել, քանի դեռ տվյալները ունեք, նոր հարցերին պատասխանելը պարզապես նոր read model-ի կամ projection-ի կառուցման հարց է, որը կենտրոնանում է դրանց համապատասխան կողմերի վրա։
Սա արդեն շատ անգամ պատահել է ինձ հետ. երբեմն բիզնեսը ուղարկում էր ad-hoc հաշվետվությունների հարցումներ, որոնք մենք կարողանում էինք կատարել իրադարձությունների տվյալներով, իսկ այլ դեպքերում ստեղծվում էին նոր read կողմի event handler-ներ՝ մեր պատմական տվյալների մի մասը արտաքին համակարգեր ուղարկելու համար՝ նոր բիզնես ֆունկցիայի նպատակով և այլն։
Ընդհանուր առմամբ, որքան երկար է սերվիսն աշխատում և որքան շատ տվյալ է կուտակում, այնքան մեծ է հավանականությունը, որ այդ տվյալները կօգնեն նոր բիզնես որոշումներում, որոնց մասին ոչ ոք չէր մտածել սերվիսը սկզբում ստեղծելիս։
Ամփոփում
Առայժմ այսքանն է։ Այս առաջին, բավականին երկար մասում ես կենտրոնացա event-sourced համակարգերի մի քանի ավելի քիչ ակնհայտ հատկությունների վրա, որոնք կապված են նրանում վիճակի ներկայացման հետ։ Խոսեցի նաև ժամանակով ճամփորդելու հնարավորության մասին՝ ինչպես դա անել և ինչ է դա նշանակում ինժեներների համար՝ խնդիրները հետազոտելիս և սխալները շտկելիս, և product մարդկանց համար, ովքեր կարող են աճեցնել բիզնեսը՝ տվյալների մասին ավելի խորը պատկերացում ստանալով։
Հաջորդ մասում կկենտրոնանամ event sourced համակարգերի մոդելավորման պրակտիկաների և մի քանի թակարդների վրա՝ ըստ էության, թե ինչպես բարձրացնել շանսերը, որ դրանք կառուցելիս ինքներդ ձեզ ոտքին չեք կրակի։ 3-րդ մասում կդիտարկեմ իրադարձությունների պահպանման առկա տարբերակները, որտեղ համահունչությունը հիմնական գործոններից մեկն է։
Մնացեք մեզ հետ։