Ինչ կցանկանայի իմանալ Event Sourcing-ով սկսելիս, մաս 3. պահպանում
Դիտարկենք իրադարձությունները պահպանելու մեր ունեցած տարբերակները՝ որպես հիմնական չափանիշներից մեկը համարելով հետևողականությունը (consistency)։
Նախորդ մասում անդրադարձանք event-sourced համակարգերում տվյալների հետևողականության հարցերին։ Ընթերցման կողմի տվյալների հետևողականությունը շոշափեցինք միայն համառոտ, քանի որ հենց այնտեղ են հետևողականության հետևանքներն ամենից հաճախ նկատվում և քննարկվում։ Սակայն event-sourced համակարգերում կա տվյալների հետ կապված ևս մեկ վճռորոշ կողմ՝ գրառման կողմը, որտեղ իրադարձությունները պահպանվում են որպես հրամանների մշակման արդյունք։ Այս մասում համառոտ կդիտարկենք իրադարձությունները պահպանելու մեր ունեցած տարբերակները՝ հետևողականությունը համարելով հիմնական չափանիշներից մեկը։
Ի՞նչն է դարձնում event store
Ի՞նչ պետք է առաջարկի տվյալների բազան կամ պահպանման ցանկացած այլ մեխանիզմ, որպեսզի event-sourced համակարգում իրադարձությունների պահպանման իրատեսական թեկնածու լինի։ Ակնհայտ է, որ պահոցը պետք է լինի դիմացկուն (durable)։ Այն նաև պետք է ապահովի գործարքների մեկուսացման համապատասխան մակարդակ, որպեսզի կարդացվեն միայն ամբողջությամբ commit արված տվյալները։ Քանի որ գործ ունենք միայն հավելվող մատյանների հետ, օգտակար է, եթե համակարգն առաջարկում է ընդունելի insert արտադրողականություն (update-ներն ու delete-ները այստեղ քիչ նշանակություն ունեն)։
Դրանից բացի այն պետք է՝
- առաջարկի ատոմար և հաջորդական գրառումներ (երբ իրադարձությունների շարք է գրվում միանգամից),
- աջակցի դասավորված հաջորդական ընթերցումներին, գոնե տվյալ aggregate-ի սահմաններում (այդ aggregate-ին պատկանող իրադարձությունների ամբողջ հաջորդականության բեռնում),
- աջակցի գլոբալ դասավորված հաջորդական ընթերցումներին, որպեսզի բոլոր իրադարձությունները կարելի լինի կարդալ դրանց պահպանման հերթականությամբ։
Այս պահանջները մեր ընտրությունը զգալիորեն նեղացնում են մինչև տվյալների բազաների լուծումներ, քանի որ մեզ պետք է առնվազն ACID երաշխիքների մեծ մասը, ինչպես նաև տվյալների բազաների առաջարկած այլ հնարավորություններ (ֆիլտրում, ինդեքսավորում և այլն)։
Համացանցում շարունակվում է Kafka-ն որպես event sourcing պահոց հարմար լինելու մասին բավական թեժ քննարկումը (ժամանակին մենք նույնիսկ երկու-երեք բավական երկար քննարկում ունեցանք այդ մասին մեր ընկերության գործընկերների հետ)։ Kafka-ն հիանալի է իրադարձությունների հետ աշխատելիս, բայց իմ կարծիքով առանձնապես օգտակար չէ այստեղ պահանջվող իրադարձությունների «մշակման» համար, ինչի մասին ավելի ներքևում։
Ի՞նչ է իրադարձությունը
Պահոցի կողմից դիտարկելիս event-sourced համակարգի իրադարձությունը կարելի է համարել կառուցվածքավորված տվյալ, որն ունի առնվազն այս հատկանիշները՝
- Aggregate ID՝ aggregate-ը, որին պատկանում է իրադարձությունը։
- Sequence Number՝ նրա դիրքը տվյալ aggregate-ի իրադարձությունների հոսքում։
- Timestamp՝ իրադարձության գրանցման պահը։
- Payload՝ իրադարձության իրական «բովանդակությունը»։
Այլ օգտակար, թեև ոչ խստորեն պարտադիր հատկանիշները ներառում են՝
- Global Sequence ID՝ հարմար է համակարգի մասշտաբով projection-ների համար։
- Tags՝ նույնպես հարմար է համակարգի մասշտաբով projection-ների, խմբավորումների և այլնի համար։
Կարող են լինել պահոցին կամ լուծմանը հատուկ լրացուցիչ դաշտեր, բայց հիմնականում սա այն ամենն է, ինչ մեզ պետք է իրադարձությունը event store-ում գրելու և հետագայում հետ կարդալու համար, երբ հրամանը մշակելու նպատակով վերարտադրում ենք տվյալ aggregate-ի իրադարձությունների հոսքը։ Ուրեմն ինչպե՞ս են տարածված տվյալների բազաները համապատասխանում այս պահանջներին։
Ռելյացիոն տվյալների բազաներ
Զարմանալի չէ, որ ռելյացիոն տվյալների բազաները այստեղ բավական հուսալի տարբերակ են։ Նրանք ընդհանուր առմամբ բավարարում են մեր ACID պահանջները, իսկ վերջերս ավելի մեծ մասշտաբի խնդիրների համար տարածում ստացած shard-ավորված/բազմահանգույց լուծումներով մասշտաբայնությունը և հետևողականությունը երբեմն կարելի է կարգավորել։
Իրադարձությունները պահվում են մեկ աղյուսակում, որը կարող է հղվել aggregate ID-ին առանձին աղյուսակից, քանի որ aggregate ID-ն յուրաքանչյուր իրադարձության մեջ դնելը կարող է ցանկալի չլինել։ Երբ ID-ն երկար է, ավելի լավ է տեղ խնայելու համար foreign key-ով հղվել մեկ այլ աղյուսակի։ Որոշ RDBMS-ներ թույլ են տալիս event աղյուսակները բաժանել ըստ ժամանակի (partition) կամ shard-ավորել (օրինակ՝ aggregate ID-ների միջակայքերով)՝ երկարաժամկետ արտադրողականությունը, հատկապես ընթերցումների համար, բարելավելու նպատակով։ Ըստ ժամանակի shard-ավորումը հատկապես հարմար է, երբ օգտագործվում են իրադարձությունների հոսքի snapshot-ներ. այդ դեպքում վերարտադրման համար պետք են միայն վերջին մի քանի իրադարձությունները։
Aggregate-ի ներսում sequence number-ները ծառայում են երկու նպատակի՝ իրադարձությունների դասավորում և optimistic concurrency control, որը կանխում է միաժամանակյա գրառումները (երբ հավելվածը չի ապահովում single-writer սկզբունք, ինչպես Akka/Pekko Persistence-ը)։ Aggregate-ի հոսքերի ներսում sequence number-ները հավանաբար լավագույնս կառավարվում են բացահայտ հավելվածի կողմից (optimistic concurrency control-ի պատճառով), մինչդեռ գլոբալ sequence number-ները սովորաբար կարելի է ավտոմատ գեներացնել sequence-ներից։ Սակայն սա թերություններ ունի. օրինակ՝ Postgres-ում sequence number-ները աճում են առանձին գործարքներում, ինչը կարող է գլոբալ sequence-ում բացթողումների կամ անկարգ արժեքների հանգեցնել (օրինակ՝ իրադարձություններին sequence number է տրվել, բայց դրանք պահող գործարքը որևէ պատճառով հետ է գլորվել կամ ձախողվել)։ Դա բարդացնում է ընթերցման կողմը։
Ինչ վերաբերում է ընթերցման կողմին, RDBMS-ների թույլ կողմերից մեկն այն է, որ նրանք սովորաբար չունեն հատուկ մեխանիզմներ իրադարձությունների հոսքերը read model-ների/subscription-ների/projection-ների համար կարդալու։ Դա սպասելի է, քանի որ դրանք կառուցված չեն եղել այս օգտագործման դեպքը նկատի ունենալով։ Բնիկին ամենամոտ տարբերակները CDC-ի (Change Data Capture) տարատեսակներն են՝ հիմնված կա՛մ trigger-ների, կա՛մ op-log-երի վրա (Postgres-ում՝ Write-Ahead-Log-ը logical decoding հնարավորության հետ համադրված)։ Դրանք ընթերցման կողմում պահանջում են բավական շատ կոդ՝ իրադարձությունները կարդալու, հոսքավորելու և հետո հուսալիորեն մշակելու ենթակառուցվածքը կառուցելու համար։
Այլընտրանքորեն կարող եք դիմել իրադարձությունների աղյուսակի հին լավ polling-ին՝ հետևելով իրադարձության sequence number-ին։ Կախված նրանից՝ read model-ը վերաբերում է մեկ aggregate-ի թե ամբողջ համակարգին (օրինակ՝ ըստ tag-երի), հետևում եք կա՛մ aggregate-ի sequence number-ին, կա՛մ գլոբալինին։ Սակայն այստեղ վիշապներ կան, քանի որ վերը նկարագրված բացթողումները և խառը դասավորությունը կարող են խնդիրներ առաջացնել։ Համոզվելու համար, որ ընթերցման կողմում ոչ մի իրադարձություն բաց չի թողնվում, պետք է ինչ-որ հսկողության և սպասման մեխանիզմ, ինչը, օրինակ, հենց այն է, ինչ Akka/Pekko Persistence Query-ն անում է ներսից։
Եվս մեկ մոտեցում է գլոբալ դասավորության համար հենվել Postgres-ի ներքին գործարքների ID-ների (xid) վրա։ Դրանց իմաստաբանությունը «ավելի լավ» է համապատասխանում մեր օգտագործման դեպքին։ Եթե ուզում եք մանրամասները, խորհուրդ եմ տալիս հենց այս թեմային նվիրված բլոգային գրառումը՝ Ordering in Postgres Outbox։
RDBMS-ները ամփոփելով՝ նրանք բավական լավ են գրառման կողմում և դեռ ամենատարածված ընտրությունն են, նույնիսկ ավելի մեծ համակարգերում։ Իրենց օգտագործման հեշտության և ծանոթ հասկացությունների դիմաց ընթերցման կողմում պետք է լրացուցիչ աշխատանք կատարել, բայց երբ այն արդեն կա, սովորաբար աշխատում է առանց խափանումների։
NoSQL տվյալների բազաներ
Սա պահպանման շարժիչների հաջորդ ընտանիքն է, որը կարող է ծառայել որպես event store։ Հավանաբար ամենահայտնիներն են Cassandra-ն (կամ ScyllaDB-ն) և AWS-ի DynamoDB-ն՝ երկուսն էլ սյունակային տվյալների բազաներ, և MongoDB-ն՝ փաստաթղթային տվյալների բազա։ Ես Cassandra-ն որպես event sourcing պահոց օգտագործել եմ միայն կարճ ժամանակ (ի վերջո տեղափոխվեցինք Postgres), ուստի ստորև ասվածը ավելի շատ այս թեմայի վերաբերյալ իմ հետազոտությունից է, քան գործնական փորձից։
Փաստաթղթային, առանց սխեմայի մոդելները կարող են ավելի լավ համապատասխանել իրադարձություններին, քանի որ առաջարկում են ավելի մեծ ճկունություն՝ կախված նրանից, թե ինչպես եք նախագծում իրադարձության payload-ը (կա՛մ որպես հավելվածի կառավարվող սերիալիզացված տվյալների blob, ինչպես RDBMS-ում, կա՛մ որպես առաջին կարգի կառուցվածք տվյալների բազայի փաստաթղթի ներսում)։ Փաստաթղթային տվյալների բազաներում (օրինակ՝ MongoDB) իրադարձությունները կարելի է պահել կա՛մ մեկ փաստաթղթում (մեկ փաստաթուղթ ամեն aggregate-ի համար), կա՛մ առանձին փաստաթղթերում։ Յուրաքանչյուր տարբերակ ունի առավելություններ և թերություններ. օրինակ՝ մեկ փաստաթուղթը կարող է ունենալ չափի սահմանափակում, ինչը կարող է խնդիր դառնալ, եթե aggregate-ը շատ մեծանա։ Մյուս կողմից՝ մեկ փաստաթղթի վրա գործողությունները բնությամբ ACID-համապատասխան են։ MongoDB-ն աջակցում է բազմափաստաթղթային գործարքների, բայց դրանք կարող են արտադրողականության գին ունենալ. անվճար ճաշ չկա։
MongoDB-ն օգտագործում է shard-ավորում, որը բնականաբար թույլ է տալիս իրադարձությունները բաշխել shard-երի միջև՝ տալով ավելի մեծ պաշար մեծ ծավալի իրադարձություններ մշակելու համար։
Ինչպես RDBMS-ում, հավելվածն ինքը պետք է պահպանի մեկ aggregate-ի իրադարձությունների sequence number-ները, բայց MongoDB-ի հիմնական թույլ կողմը, կարծես, այն է, որ այն չունի իրադարձությունները գլոբալ հաջորդականացնելու ներկառուցված եղանակ՝ առանց ձեր կողմից լրացուցիչ տրամաբանության և մշակման։ Քանի որ MongoDB-ն օգտագործում է leader-follower ճարտարապետություն, և ամեն գրառում անցնում է leader-ի միջով, sequence գեներատորի դեր կատարող առանձին collection-ը պետք է հնարավոր լինի (թեև սա հավանաբար պահանջում է բազմափաստաթղթային գործարքներ և հետևաբար հնարավոր արտադրողականության ծախսեր)։ Ոչ պաշտոնապես MongoDB-ն փաստաթղթերը պահում է կայուն ներդրման կարգով, բայց որքան գիտեմ, դա փաստաթղթավորված չէ, և դրա վրա հենվելը խորհուրդ չի տրվում։
Սյունակային տվյալների բազաներում, ինչպիսին Cassandra-ն է, իրադարձությունները կարող են պահվել որպես սյունակներ տողում, որի partition key-ը aggregate ID-ն է, իսկ clustering key-ը՝ այդ aggregate-ի հոսքում sequence number-ը, ինչը հնարավորություն է տալիս իրադարձությունները դասավորել մեկ aggregate-ի ներսում։ Ցավոք, քանի որ Cassandra-ն բաշխված է և առանց leader-ի, այն չունի բոլոր իրադարձությունների գլոբալ հաջորդականացման/դասավորման ներկառուցված մեխանիզմ, ուստի հավելվածը պետք է դրան հոգա։ Ինչո՞ւ է գլոբալ դասավորությունը օգտակար։ Երբ ուզում եք հետևել իրադարձություններին բազմաթիվ entity-ների վրա (օրինակ՝ արձագանքել միայն որոշակի տեսակի իրադարձություններին), պետք է եղանակ հետևելու և checkpoint անելու արդեն տեսած և մշակված իրադարձությունները, որպեսզի կարողանաք շարունակել այդ կետից։
Քանի որ Cassandra-ն բաշխված է, կարող են տեղի ունենալ հակասող գրառումներ, որոնք լուծվում են timestamp-ների վրա հիմնված «last-one-wins» ռազմավարությամբ։ Սա երբեմն կարող է իրադարձությունների կորստի հանգեցնել։ Դեղամիջոցներից մեկը հետևողականության մակարդակները պատշաճ սահմանելն է, օրինակ՝ QUORUM կամ ALL, երբ պահանջվում է խիստ հետևողականություն, բայց դա, իհարկե, ազդում է latency-ի վրա։
Այդուհանդերձ, լինելով առանց leader-ի և բաշխված, Cassandra-ն հիանալի է համապատասխանում գրառումներով ծանրաբեռնված, ընթերցումներով ծանրաբեռնված (եթե ընթերցումները key-ի վրա հիմնված են) և հնարավոր է աշխարհագրորեն բաշխված հավելվածների համար, որոնք կարող են տվյալների հետևողականության մի մասից հրաժարվել հասանելիության դիմաց։
Ե՛վ MongoDB-ի, և՛ Cassandra-ի համար ես չգիտեմ իրադարձությունների հոսքերին բաժանորդագրվելու որևէ բնիկ, ներկառուցված մեխանիզմ, ուստի կրկին սա պետք է արվի բացահայտորեն polling-ով կամ CDC մեխանիզմներով (օրինակ՝ Debezium-ը Cassandra CDC-ի հետ կամ միացված MongoBD replicaSet-ով)։
Եվս մեկ նկատառում հետևողականության մասին. Գրեգ Յանգը, մարդը, ով «հնարել է» Event Sourcing-ը, հիանալի զեկույց է արել հենց այս թեմայով՝ event store-ի հետևողականությունը գրառման կողմում, հատկապես աշխարհագրորեն բաշխված համակարգերում։ Խստորեն խորհուրդ եմ տալիս դիտել այն։
Մասնագիտացված event store-եր
Շուկան առաջարկում է մի քանի արտադրանք, որոնք կառուցված են հիմնականում event sourcing օգտագործման դեպքերի համար։ Դրանք տվյալների բազաներ են, որոնք նախագծված են իրադարձությունները որպես հոսքեր պահելու և ընթերցման կողմին այդ իրադարձությունները հարցման ենթարկելու հնարավորություն տալու համար։ Հավանաբար ամենահայտնին EventStoreDB-ն է, որը ստեղծել է հենց Գրեգ Յանգը։ Մեկ այլ, որը ես գիտեմ, Axon Server-ն է, որի հիմնական բաղադրիչների թվում event store կա։ Axon Server-ը պատկանում է Axon stack-ին՝ Java էկոհամակարգի համար նախատեսված event sourcing լուծմանը։
Ընդհանուր առմամբ այս լուծումները լուծում են վերը նկարագրված մոտեցումների թույլ կողմերից մի քանիսը (թեև ոչ բոլորը)։
Ինձ համար EventStoreDB-ի ամենաարժեքավոր հատկանիշը subscription-ների և ընթերցման կողմի տարբեր հարցումների ներկառուցված աջակցությունն է՝ իրադարձությունների գլոբալ դասավորության հետ միասին։ Յուրաքանչյուր հոսք բնականաբար ունի իր հաջորդականացված ID-ները՝ խիստ մոնոտոն աճի երաշխիքով (առանց բացթողումների)։ Դրանից բացի՝ յուրաքանչյուր իրադարձություն նաև գլոբալ հաջորդականացվում է, այնպես որ կարող եք կարդալ այսպես կոչված $all հոսքը իրադարձությունների պահպանման հերթականությամբ։ Իրադարձության գլոբալ դիրքը հոսքում «prepare position»-ի և «commit position»-ի կոմպոզիտ է, ինչը երաշխավորում է իրադարձությունների ճիշտ դասավորությունը։
EventStoreDB-ն առաջարկում է նաև «projection»-ների գեղեցիկ հասկացություն, որը ըստ էության թույլ է տալիս ստեղծել նոր, միջանկյալ հոսք՝ կազմված որոշակի չափանիշներին (օրինակ՝ իրադարձության տեսակ) համապատասխանող իրադարձություններից, և բաժանորդագրվել դրան catch-up subscription-ով։ Սա թույլ է տալիս մաքուր կազմակերպել և ընդլայնել ձեր ընթերցման կողմը՝ projection-ներն ու subscription-ները ձևավորելով ինչպես ցանկանաք։
Սակայն EventStoreDB-ն օգտագործում է leader-follower ճարտարապետություն, ուստի այն այնքան լավ չի մասշտաբավորվում, որքան, ասենք, առանց leader-ի Cassandra-ն. ամեն գրառում դարձյալ պետք է անցնի leader-ի միջով, թեև follower-ներին և միայն ընթերցման հանգույցներին կրկնօրինակումը բարելավում է հասանելիությունը և սխալների հանդուրժողականությունը։
Ընդհանուր առմամբ մասնագիտացված event store-երը արտադրանքներ են, որոնք դժվար է մեկ առ մեկ համեմատել RDBMS-ների կամ NoSQL տվյալների բազաների հետ։ Իրենց հատուկ նպատակի պատճառով նրանք օգտագործում են նորարար մոտեցումներ, որոնք մյուս լուծումներին բնականաբար պակասում են, օրինակ՝ ներկառուցված subscription-ներ, կատեգորիաներ և այլն։ Արդյոք դրանցից որևէ մեկը լուծում է ձեր event sourcing խնդիրը, մեծապես կախված է ձեր օգտագործման դեպքից, ուստի, ինչպես միշտ, օգտվեք ձեր դատողությունից և մանրակրկիտ հետազոտեք՝ նախքան լիովին հանձնառու դառնալը։
Իսկ ի՞նչ կասեք Kafka-ի մասին
Kafka-ն իրադարձությունների հետ աշխատում է շատ լավ, բայց իսկապես գերազանցում է բարձր թողունակությամբ, սխալների նկատմամբ կայուն իրադարձությունների հոսքավորման մեջ։ Որպես event store (այն իմաստով, որ պահանջում են event-sourced հավելվածները)՝ այն ունի որոշ սահմանափակումներ, որոնք այն դարձնում են այս գործին քիչ հարմար։ Արագ անցնենք դրանցից մի քանիսով։
Սկզբից՝ Kafka-ն իրադարձությունների դասավորությունը երաշխավորում է միայն topic-ի մեկ partition-ի ներսում։ Այսպիսով, մեկ հոսքի ներսում իրադարձությունների դասավորությունը երաշխավորելու համար պետք կլիներ կա՛մ partition մեկ հոսքի համար, կա՛մ մեկ partition-անոց topic յուրաքանչյուր aggregate-ի համար։ Սակայն ոչ մի մոտեցում լավ չի մասշտաբավորվում։
Պատշաճ event store-ը պետք է հնարավորություն տա արագ վերարտադրել տվյալ aggregate-ի իրադարձությունները։ Kafka-ն կարելի է կարգավորել իրադարձությունները երկար պահելու համար իր retention պարամետրերով, բայց ամբողջ հոսքից տվյալ aggregate-ի իրադարձությունները ընտրելու արդյունավետ եղանակ չկա, եթե aggregate-ները չբաժանենք վերը նկարագրածի պես, ինչը գործնական չէ։
Kafka-ի վրա իրադարձություններ պահպանելիս concurrency control իրականացնելու եղանակ չկա, ինչը կարող է վտանգել տվյալների հետևողականությունը։ Որոշ կոնֆլիկտներ կարելի է հայտնաբերել և մշակել կոդում, բայց դա անել բոլոր հնարավոր դեպքերի համար գործնական չէ։ Սա մեղմելու եղանակներից մեկը single-writer սկզբունքի կիրառումն է և concurrency control-ը ամբողջությամբ հավելվածի մակարդակում մշակելը։
Սրանք Kafka-ն որպես իսկական event store օգտագործելու թերություններից միայն մի քանիսն են։ Այդ խնդիրներից որոշները, անշուշտ, կարելի է շրջանցել լրացուցիչ գործիքներով և ենթակառուցվածքով, ինչպիսիք են ksqlDB-ն, Kafka Streams-ը, topic-ները և partitioning ռազմավարությունները, բայց իմ տպավորությամբ՝ որքան ավելի շատ դեպքեր փորձեք ծածկել, կարգավորումը էքսպոնենցիալ բարդանում է։
Ինձ սխալ չհասկանաք. ես սիրում եմ Kafka-ն և լայնորեն օգտագործում եմ այն տվյալների հոսքավորման համար և որպես message broker։ Հենց այնտեղ է այն անժխտելիորեն փայլում, և այնտեղ է մնում շուկայի գերիշխող խաղացող։ Այն պարզապես լավ ընտրություն չէ որպես event store։
Ամփոփում
Անցանք event-sourced համակարգում իրադարձությունները պահելու մի քանի հասանելի տարբերակներով՝ ամենատարածված RDBMS-ներից, բարձր մասշտաբայնությամբ և բաշխված NoSQL-ների միջով մինչև մասնագիտացված event store տվյալների բազաներ։ Յուրաքանչյուր տարբերակ ունի իր ուժեղ և թույլ կողմերը event sourcing-ի պահանջների տարբեր ասպեկտներում, սակայն ռելյացիոն տվյալների բազաները դեռ ամենատարածված ընտրությունն են՝ իրենց տարածվածության և ճկունության շնորհիվ։ Խորքում ցանկանում եմ, որ մասնագիտացված event store-երն ավելի տարածված լինեին և շուկայի ավելի մեծ մասն ունենային, քանի որ նրանք կարող են տրամադրել հիանալի լուծումներ, որոնք կառուցված են հատկապես event-sourced հավելվածների համար։