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

Բարձր հասանելիությամբ, բազմաշրջանային (multi-regional) պլանավորիչի ստեղծումը AWS-ում

Քայլ առ քայլ ձեռնարկ՝ AWS-ի ծառայություններով բազմաշրջանային, բարձր հասանելիությամբ պլանավորիչ կառուցելու մասին, որը կրիտիկական աշխատանքային հոսքերի համար երաշխավորում է առնվազն մեկ անգամ առաքման (at-least-once) քաղաքականություն։

17 րոպե
ՃարտարապետությունԾրագրային ճարտարապետությունԲարձր հասանելիությունAWSՀամակարգային ճարտարապետությունՀամակարգերի նախագծում

Ժամանակակից բաշխված համակարգերը հաճախ ընդգրկում են մի քանի շրջան (region)՝ բարձր հասանելիություն և ցածր հապաղում ապահովելու համար։ Նման համակարգերին հաճախ անհրաժեշտ է HTTP հարցումները հետագա կատարման համար պլանավորելու միջոց, ինչը ապահովում է այնպիսի աշխատանքային հոսքեր, ինչպիսիք են ծանուցումները, հետաձգված API կանչերը կամ ժամանակով գործարկվող տրիգերները։ Մի քանի շրջաններում տեղակայելիս այսպիսի պլանավորիչը պետք է հաղթահարի այնպիսի մարտահրավերներ, ինչպիսիք են համահունչությունը (consistency) և ճկունությունը՝ failover-ի ժամանակ։ Այս հոդվածը բացատրում է, թե ինչպես ստեղծել բազմաշրջանային, բարձր հասանելիությամբ պլանավորիչ AWS-ի ծառայություններով, որը կրիտիկական աշխատանքային հոսքերի համար երաշխավորում է առնվազն մեկ անգամ առաքման (at-least-once) քաղաքականություն։

Գործիքը պետք է բավարարի նաև մի քանի այլ պահանջների.

  • Այն պետք է կարողանա վայրկյանում ուղարկել հազարավոր հարցումներ վայրկյանների ճշտությամբ (հաջող սցենարում. ծառայության խափանումների ժամանակ դրանց փոքր-ինչ ուշ առաքումը թույլատրելի է)։
  • Առնվազն մեկ անգամ առաքումը պարտադիր է։ Դրանից բացի, պետք է ձգտել հնարավորինս ճշգրիտ մեկ անգամ առաքման (best-effort exactly-once)։
  • Յուրաքանչյուր հարցում պետք է ուղարկվի այն շրջանից, որտեղ ստեղծվել է (ծախսերը խնայելու և տվյալների համահունչությունը պարզեցնելու համար). մեր թիրախային endpoint-ները կարող են լինել շրջանային, ուստի պլանավորիչը պետք է իմանա, թե որ շրջանից պետք է հարցումն ուղարկվի։
  • Այն պետք է աջակցի շրջանի failover-ին (region failover). մենք պետք է կարողանանք դատարկել պլանավորիչից մեկ շրջանում դուրս եկող տրաֆիկը և այն ամբողջությամբ տեղափոխել մեկ այլ շրջան, որպեսզի բոլոր պլանավորումները առաքվեն այնտեղից (օրինակ՝ թեև որոշակի պլանավորումներ ստեղծվել են us-east-1-ում, շրջանի failover-ի ժամանակ դրանք պետք է առաքվեն us-east-2-ում)։ Շրջանի failover-ը չի նշանակում անջատել այդ շրջանի բոլոր սերվիսային ինստանսները։

Ինչո՞ւ չհիմնվել Event Bridge Scheduler-ի վրա

Դա, անշուշտ, մեր առաջին գաղափարն էր, քանի որ այն թվում էր պատրաստի լուծում, որը կհամապատասխանի մեր դեպքին, բայց ավելի մանրակրկիտ ուսումնասիրությունը բացահայտեց հետևյալ խնդիրները.

  • Այն չի աջակցում HTTP endpoint-ները որպես պլանավորիչի թիրախ։ Միջանկյալ շերտ կարող է լինել Lambda-ն, ինչը մեծ խնդիր չէ, բայց ճարտարապետությանը բարդություն է ավելացնում
  • Ավելի կարևոր է, որ EventBridge scheduler-ի պլանավորումները չեն կրկնօրինակվում և չեն համաժամեցվում շրջանների միջև, ուստի շրջանի failover-ը «արկղից դուրս» չի աջակցվում։ Որոշակի շրջանում ստեղծված պլանավորումները նույնպես պետք է առաքվեին այդ շրջանից։

Ընդհանուր առմամբ, EventBridge Scheduler մոտեցումը մեր պահանջների հետ համեմատելուց հետո եզրակացրինք, որ այս ճարտարապետությանը դրանք բավարարել տալու համար մեզ հարկ կլիներ այս AWS ծառայությունը շրջապատել բազմաթիվ լրացուցիչ «փազլի կտորներով»։ Դա կարող էր ամբողջ կառուցվածքը դարձնել շատ բարդ և հնարավոր է՝ անկայուն։ Այս ամենը հաշվի առնելով՝ դժվար թե այն կարելի լիներ համարել պատրաստի լուծում։ Իսկ սեփական գործիքը ավելի մեծ ճկունություն կառաջարկեր և թույլ կտար ընդլայնել աջակցվող հնարավորությունների շրջանակը՝ մեր կարիքների փոփոխմանը զուգընթաց։ Ահա թե ինչու ընտրեցինք կառուցել մեր սեփական պլանավորիչը և տեղակայել այն multi-AZ և բազմաշրջանային կոնֆիգուրացիայով։ Հաջորդ բաժիններում ներկայացված է այս գաղափարի բարձր մակարդակի ճարտարապետությունը։

Պահպանվածություն (persistency) և պարզ API

Սկզբում ուզում ենք պլանավորումները պահել տվյալների բազայում և այնտեղ պահել ողջ տեղեկատվությունը, ինչը հեշտացնում է կառավարումն ու աուդիտը։

Մենք ընտրեցինք DynamoDB, քանի որ NoSQL տվյալների բազան կառաջարկեր լավ արտադրողականություն և մասշտաբավորելիություն, և լավ պլանավորված տվյալների կառուցվածքի դեպքում կկարողանայինք յոլա գնալ առանց բարդ հարցումների։

Դրանից բացի, որոշեցինք օգտագործել DDB global table հնարավորությունը՝ մեր շրջանների միջև active-active կրկնօրինակումից օգտվելու համար՝ շրջանի failover-ին աջակցելու նպատակով (այդ մասին՝ ավելի ուշ)։

Թեժ բաժանումներից (hot partitions) խուսափելու համար scheduleId-ն ծառայում է որպես partitionKey։ Նրա արժեքը կարող է գեներացվել պլանավորումը ստեղծելիս։

Երբ կա բոլոր պլանավորումները պահող տվյալների բազա, կարող ենք ցուցաբերել API՝ դրանց վրա CRUD գործողություններ կատարելու համար։

Քեշ

Սկզբունքորեն, հոդվածը կարող էինք ավարտել հենց այստեղ՝ կառուցելով Sender բաղադրիչ, որը ամեն վայրկյան հարցում է անում DynamoDB աղյուսակին (ինչի համար կպահանջվեր առանձին GSI (Global Secondary Index) արժեք՝ որոշակի վայրկյանին հասունացած բոլոր պլանավորումները ստանալու համար) և դրանք պարզապես ուղարկում է իրենց թիրախային endpoint-ներին։

Որքան էլ պարզ հնչի, դա լավագույն գաղափարը չէ, քանի որ DynamoDB աղյուսակին ամեն վայրկյան հարցում անելը մեծ բեռ կդներ նրա վրա և կբարձրացներ ճարտարապետության ընդհանուր արժեքը։ Շատ ավելի խելամիտ մոտեցումը պլանավորումները բաժանելն է բաքեթների (buckets), օրինակ՝ 10 րոպեանոց հատվածների, դրանք նախօրոք բեռնել քեշ և, երբ ժամանակը գա, դրանք փնտրել քեշում և ուղարկել հասունացածները։

Բազայից պլանավորումները ուղղակիորեն կարդացող Sender-ը՝ համեմատած քեշի շերտի վրա հիմնվող Sender-ի հետ։

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

Նկատեք, որ այս 10 րոպեանոց բաքեթները պետք է լինեն շրջանային, այսինքն՝ յուրաքանչյուրը պարունակում է պլանավորումներ միայն մեկ շրջանից։

Երկու շրջաններում նույն ժամանակային պատուհանն ընդգրկող երկու բաքեթները պարունակում են տարբեր շրջանային պլանավորումներ։

Ո՞ր ծառայությունը կարող է գործել որպես քեշի շերտ

Մենք արագ բացառեցինք հիշողության (in-memory) քեշը, քանի որ մեր սերվիսը պետք է աշխատի բազմաշրջանային կոնֆիգուրացիայով և, քեշավորման տեսանկյունից ավելի կարևորը՝ բազմաինստանս (մեկ շրջանի ներսում), ուստի քեշը պետք է կիսվի շրջանային ինստանսների միջև՝ դրանք համաժամեցված պահելու համար (այսինքն՝ չենք ուզում, որ յուրաքանչյուր ինստանս ուղարկի բոլոր պլանավորումները, ինչը կարող էր պատահել, եթե յուրաքանչյուր ինստանս ունենար իր քեշը)։

ElastiCache-ը սկզբում թվում էր մեր լավագույն տարբերակը, բայց ի վերջո մենք ընտրեցինք SQS հերթ։ Այս (հավանաբար անսպասելի) ընտրությունը պայմանավորված է հետևյալ պատճառներով.

  • SQS հերթի հաղորդագրությունները պահպանվող (persistent) են (նույնը կարելի էր ապահովել ElastiCache-ով Redis-ի հետ, բայց դրա համար կպահանջվեին լրացուցիչ «փազլի կտորներ»)։ Այսպիսով, երբ պլանավորումը հայտնվում է CacheQueue-ում, կարող ենք ապավինել նրա առնվազն մեկ անգամ առաքման քաղաքականությանը և վստահ լինել, որ Sender-ը ի վերջո կմշակի պլանավորումը։
  • SQS հերթը որպես քեշ օգտագործելը թույլ է տալիս աշխատեցնել մեկից ավելի Sender առանց դրանք համաժամեցնելու անհրաժեշտության։
  • Եթե Sender-ը որևէ պատճառով անսպասելիորեն ձախողվի, կարող ենք ապավինել հերթի կրկնության (retry) քաղաքականությանը։
  • SQS-ն առաջարկում է message timers հնարավորությունը, որն ընտրեցինք օգտագործել, որպեսզի պլանավորումները կարողանան կատարվել ճշգրիտ պահին, թեև դրանք նախօրոք քեշավորվել են։

Sender

Այստեղ ոչ մի առանձնապես բարդ բան չկա. Sender բաղադրիչը պարզապես հարցում է անում CacheQueue-ին հաղորդագրությունների համար և պլանավորումներն ուղարկում է հենց որ դրանք հայտնվում են։ Արտադրողականությունը բարձրացնելու համար կարելի է գործարկել մի քանի Senders (պարզության համար կօգտագործենք մեկը)։ Հաջող առաքումից հետո պլանավորումները նշվում են որպես ուղարկված (նրանց GSI-ը հեռացվում է, և կարգավիճակը թարմացվում է) և պահպանվում տվյալների բազայում։

Reader

Բարձր մակարդակով այս բաղադրիչի խնդիրն է որոշակի պահին «արթնանալ», տվյալների բազայից կարդալ որոշակի բաքեթը կազմող բոլոր պլանավորումները և բեռնել դրանք CacheQueue-ի վրա (նախ հաշվարկելով հետաձգումը)։

Գործնականում բաղադրիչը այսպես է երևում.

Reader բաղադրիչը, որը բաղկացած է ReaderTaskProducer-ից, FIFO հերթից և ReaderTaskConsumer-ից

ReaderTaskProducer

Այս բաղադրիչն ունի մեկ խնդիր. արթնանալ ամեն տասը րոպեն մեկ (որոշակի բաքեթի սկսվելուց փոքր-ինչ առաջ. այսպես՝ 12.10-12.20 բաքեթի համար այն կարող է արթնանալ, ասենք, 12.07-ին), այդ բաքեթի համար ստեղծել ReaderTask և դնել այն FIFO հերթում։ ReaderTask-ը պարզ հրաման է, որը Reader-ին ասում է, որ որոշակի շրջանային բաքեթը պետք է բեռնվի տվյալների բազայից և դրվի քեշում։

Սա լավ պահ է շեշտելու, որ մեր սերվիսը կարող է միաժամանակ աշխատեցնել բազմաթիվ ինստանսներ մեկ շրջանի (կամ նույնիսկ մեկ AZ-ի) ներսում։ Պետք է ապահովենք, որ ոչ մի բաքեթ կամ պլանավորում քեշում չհայտնվի մեկից ավելի անգամ։

Reader-ը երկու բաղադրիչի (ReaderTaskProducer + ReaderTaskConsumer) բաժանելու միակ պատճառը նրանց միջև SQS FIFO հերթ դնելն է։ Հերթում մեկ բաքեթի համար ճիշտ մեկ ReaderTask ստանալու համար պետք է օգտագործել SQS FIFO deduplication մեխանիզմը (deduplicationId-ն բաքեթի id է, որը նույնն է սերվիսի բոլոր ինստանսների համար)։

ReaderTaskConsumer

Reader-ի այս մասը հարցում է անում FIFO հերթին, և այնտեղ հայտնվող յուրաքանչյուր ReaderTask հաղորդագրություն մշակվում է միայն մեկ ReaderTaskConsumer-ի կողմից։ (Ավելի ճշգրիտ՝ սերվիսի այլ ինստանսներին պատկանող ReaderTaskConsumers-ը այդ գրառումը չեն մշակի։ Դա ապահովվում է VisibilityTimeout SQS հնարավորությամբ)1։

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

Ինչ վերաբերում է հենց մշակմանը. բաղադրիչը GSI-ի միջոցով հարցում է անում տվյալների բազային՝ տվյալ բաքեթի յուրաքանչյուր պլանավորումը ստանալու համար։ Այնուհետև այն հաշվարկում է յուրաքանչյուրի հետաձգումը՝ նախքան CacheQueue-ում դնելը։

GSI-ի կառուցվածքը

nextAttemptTimestamp: 2025-10-01T17:16:04Z 
gsi: us-east-1#2025-10-01T17:10:00Z

NextAttemptTimestamp-ը «կլորացվում» է ներքև՝ մինչև մոտակա 10 րոպեն՝ GSI-ն ստանալու համար, որը ներկայացնում է 10 րոպեանոց բաքեթները։

Կրկնություններ (Retries)

Ի՞նչ է պատահում, երբ պլանավորման առաքումը որևէ պատճառով ձախողվում է։ Լավագույն փորձին համապատասխան՝ գործարկվում է կրկնության քաղաքականությունը։

Կրկնությունները կառավարելու համար Sender բաղադրիչը մեծացնում է պլանավորման փորձերի հաշվիչը, հաշվարկում է հաջորդ առաքման ժամանակը (այստեղ լավ է աշխատում էքսպոնենցիալ backoff-ը jitter-ով) և դրա հիման վրա թարմացնում է գրառման GSI արժեքը (անհրաժեշտության դեպքում) և պահպանում այն տվյալների բազայում։ Արդյունքում պլանավորումը տեղափոխվում է մեկ այլ բաքեթ և մշակվում է առաջիկա բաքեթի իտերացիաներից մեկում2։
Սակայն եթե փորձերի առավելագույն քանակը սպառվել է, պլանավորումը նշվում է որպես բաց թողնված (skipped) և բարձրացվում է ահազանգ (այս հոդվածը չի անդրադառնա, թե ինչպես է իրականացվել ահազանգման մեխանիզմը)։

Հոսքի ամփոփում

  1. ReaderTaskProducers-ը ստեղծում են ReaderTasks և դնում են SQS հերթում։ Այնտեղ իրականում հայտնվում է միայն մեկ հաղորդագրություն։
  2. Մեկ ReaderTaskConsumer մշակում է ReaderTask-ը։
    a. Բաքեթը ստացվում է DynamoDb աղյուսակից։
    b. Յուրաքանչյուր պլանավորման հետաձգումը հաշվարկվում է։
    c. Յուրաքանչյուր պլանավորում դրվում է CacheQueue-ում՝ message timers հնարավորությամբ։
  3. Հետաձգումն անցնելուց հետո Sender-ը կարդում է պլանավորումը և ուղարկում է այն իր թիրախային endpoint-ին։
    a. Եթե հաջողվում է, պլանավորումը նշվում է որպես առաքված։
    b. Եթե ձախողվում է, կիրառվում է կրկնության քաղաքականությունը։

Շրջանի Failover

Ինչպես նշվեց այս հոդվածի սկզբում, այս լուծման հիմնական մարտահրավերը ցանկացած շրջանը ցանկացած պահի «անջատելու» և այնուհետև նրա բոլոր պլանավորումները մեկ այլ շրջանից առաքելու հնարավորության աջակցությունն էր (թիրախային endpoint-ները շրջանային են)։

Արժե շեշտել, որ այս ճարտարապետությունում ամբողջ աշխատանքը կատարվում է ֆոնային առաջադրանքներով։ Ուստի բոլոր CRUD API կանչերը մեկ այլ շրջանի սերվիսին ուղղորդելը բավարար չէ, քանի որ նախկինում ստեղծված պլանավորումները կշարունակեն ուղարկվել հնարավոր է՝ անսարք շրջանից։

Ուստի շրջանից տրաֆիկը լիովին դատարկելու համար failover արված շրջանի յուրաքանչյուր պլանավորիչի ինստանս պետք է անջատման հրամանը փոխանցի իր բոլոր բաղադրիչներին, որպեսզի դրանք դադարեցնեն աշխատանքը։

Նույնը վերաբերում է ստանձնող շրջանին (այն շրջանը, որը խափանման ընթացքում ուղարկում է failover արված շրջանի պլանավորումները). նրա սերվիսի ինստանսների բաղադրիչները պետք է տեղյակ լինեն ռեժիմի փոփոխության մասին։

Շրջանի failover-ի ընթացիկ կարգավիճակը մենք որոշեցինք պահել SSM Parameter Store-ում և շրջանի failover-ը հայտնաբերելու համար ստուգել արժեքի փոփոխությունները (polling)3։

Տեսնելու համար, թե ինչպես է այս պահանջն աջակցվում, սկսենք ճարտարապետության փոփոխություններից.

FailoverPoller

Այս բաղադրիչը հարցում է անում SSM պարամետրի արժեքին և հենց որ նկատում է փոփոխություն, այդ տեղեկատվությունը փոխանցում է Orchestrator-ին։

ReaderTaskProducer

Ինչպես նախկինում բացատրվեց, տվյալների բազայից ստացվող բաքեթները շրջանային են։ ReaderTask-ը հրաման է, որը ReaderTaskConsumer-ին ասում է, թե որ բաքեթը մշակի։ Շրջանի failover-ի ժամանակ ReaderTaskProducer-ը պետք է կանգնի, որպեսզի FIFO հերթը այս շրջանի համար այլևս ReaderTasks չստանա։ Արդյունքում պլանավորումները քեշում չեն դրվի և հետևաբար այս շրջանից չեն ուղարկվի։

Ստանձնող շրջանում լռելյայն ինստանսի կողքին կարելի է գործարկել լրացուցիչ ReaderTaskProducer ինստանս՝ failover արված շրջանի համար հրամաններ գեներացնելու նպատակով։ Իր հերթին ReaderTaskConsumer-ը պլանավորումները դնում է քեշում՝ Sender-ի կողմից մշակվելու համար, ինչը հնարավորություն է տալիս շրջանի լիարժեք փոխարկում4։

Sender

Sender-ին պետք է տրվի շրջանների բազմություն, որոնց պլանավորումները նա պետք է մշակի (ուղարկի)։ Լռելյայն այս բաղադրիչը մշակում է այն շրջանի պլանավորումները, որտեղ աշխատում է, բայց երբ failover է տեղի ունենում, նա պետք է անմիջապես դադարեցնի ուղարկելը։ Բացի այդ, նա պետք է մաքրի CacheQueue-ի բոլոր մնացած հաղորդագրությունները (պլանավորումները կմշակվեն մյուս շրջանում), որպեսզի failover-ի ավարտից և Sender-ի՝ լռելյայն ռեժիմով հերթից սպառելուն վերադառնալուց հետո դրանք երկրորդ անգամ չուղարկվեն։

Վերականգնող շրջանի Sender-ին, իր հերթին, պարզապես պետք է հանձնարարվի ուղարկել պլանավորումներ իր սեփական շրջանից + failover արված շրջանից5։

Orchestrator

Որպեսզի ReaderTaskProducers-ը և Sender-ը կարողանան աշխատել որոշակի ռեժիմով, որը կարելի է փոխել runtime-ում, պետք է ավելացնել Orchestrator բաղադրիչ։

Orchestrator-ը տիրապետում է Sender և ReaderTaskProducers բաղադրիչների ինստանսներին։ Դրա շնորհիվ, երբ failover-ի տեղեկատվությունը հասնում է Orchestrator-ին, նա կարող է անջատել աշխատող բաղադրիչները և, անհրաժեշտության դեպքում, գործարկել նորերը այլ ռեժիմով։

Շրջանի failover-ի օրինակ

Ենթադրենք՝ us-east-1 շրջանը պետք է անջատվի խափանման պատճառով (կամ պարզապես թեստավորման համար, ինչը, ի դեպ, նույնպես լավ պրակտիկա է)։

  1. Շրջանային SSM պարամետրերը թարմացվում են։ us-east-1-ը տարհանվում է, և us-east-2-ը դառնում է վերականգնող շրջան։
  2. FailoverPoller-ը նկատում է պարամետրի արժեքի փոփոխությունը և փոխանցում է այն Orchestrator-ին։
  3. us-east-1
    3.1 Orchestrator-ը կանգնեցնում է us-east-1-ի ReaderTasks-ը գեներացնող ReaderTaskProducer-ը։ Նա նաև հանձնարարում է Sender-ին մաքրել us-east-1 պլանավորումների հաղորդագրությունները՝ հերթը դատարկելու համար։
    3.2 Քեշը դադարում է նոր պլանավորումներ ստանալ։
    3.3 Քեշում արդեն գտնվող յուրաքանչյուր պլանավորում մաքրվում է հենց որ տեսանելի է դառնում Sender-ին, ուստի այս շրջանից ոչինչ չի ուղարկվում։
  4. us-east-2
    4.1 Orchestrator-ը գործարկում է նոր ReaderTaskProducer ինստանս, որը պատասխանատու է us-east-1 բաքեթների համար։ Նա նաև հանձնարարում է Sender-ին ուղարկել պլանավորումներ թե՛ us-east-1, թե՛ us-east-2 շրջաններից6։
    4.2 ReaderTaskProducers-ը գեներացնում են ReaderTasks us-east-1 (սկսած, օրինակ, մի քանի օր առաջվանից) և us-east-2 շրջանների համար։
    4.3. ReaderTaskConsumers-ը ստանում են բաքեթներ us-east-1 և us-east-2 շրջաններից և այդ բոլոր պլանավորումները բեռնում քեշ։
    4.4. Sender-ը ուղարկում է երկու շրջանների յուրաքանչյուր պլանավորում։

Շրջանի վերականգնման օրինակ (failover-ը անջատվել է)

  1. Շրջանային SSM պարամետրերը թարմացվում են։ Ամեն ինչ վերադառնում է նորմալ վիճակի։
  2. FailoverPoller-ը նկատում է պարամետրի արժեքի փոփոխությունը և փոխանցում է այն Orchestrator-ին։
  3. us-east-1
    2.1 Orchestrator-ը գործարկում է լռելյայն ReaderTaskProducer-ը և հանձնարարում է Sender-ին սկսել us-east-1-ի պլանավորումների ուղարկումը6
    2.2 us-east-1-ի համար գեներացվում են ReaderTasks (սկսած, օրինակ, մի քանի օր առաջվանից), և պլանավորումները հայտնվում են քեշում։
    2.3 Պլանավորումները ուղարկվում են։
  4. us-east-2
    3.1 Orchestrator-ը կանգնեցնում է us-east-1 բաքեթները մշակող ReaderTaskProducer ինստանսը։ Նա նաև հանձնարարում է Sender-ին դադարեցնել us-east-1 պլանավորումների մշակումը և ուղարկել միայն us-east-2-ինները։
    3.2 Գեներացվում են միայն us-east-2-ի ReaderTasks-ը, և այդ պլանավորումները բեռնվում են քեշ։
    3.3. Sender-ը մշակում է us-east-2 պլանավորումները։ Այդ պահից us-east-1-ի՝ քեշում դեռ մնացած ցանկացած պլանավորում մաքրվում է հերթից։

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

Այլընտրանքային մոտեցումներ և նկատառումներ

Այս ճարտարապետությունը նախագծելիս մեր առջև ծառացած մի քանի որոշումներ հիանալի կերպով ցուցադրեցին ցանկացած համակարգ նախագծելու կանոնը. փոխզիջումները (trade-offs) ամենուր են…

Փոխզիջումների մասին խոսելով՝ այս ճարտարապետությունը իրականացնելուց առաջ մենք վերանայեցինք գաղափարը և փորձեցինք բարելավումներ մտածել։ Նախ, զգացինք, որ լավ կլինի սերվիսն ավելի շատ անջատել՝ հիմնվելով գոյություն ունեցող AWS ծառայությունների վրա, այլ ոչ թե յուրաքանչյուր բաղադրիչը իրականացնելով մեկ ECS առաջադրանքի ներսում։ Բացի այդ, առաջին հայացքից polling-ի վրա հիմնված բաղադրիչները իդեալական չէին թվում։

Դա մեզ հանգեցրեց այլընտրանքի. Reader բաղադրիչը կարող էր կառուցվել նաև EventBridge scheduler + lambda թիրախով (ReaderTaskProducer + SQS FIFO + ReaderTaskConsumer-ի փոխարեն), բայց շրջանի failover-ին աջակցելու համար lambda-ն պետք է աշխատեր որոշակի ռեժիմով՝ կախված SSM պարամետրի արժեքից (հնարավոր է՝ ամեն գործարկման ժամանակ կանչելով SSM API՝ արժեքը կարդալու համար)։ Նույնը ճիշտ է Sender բաղադրիչի համար, որը նույնպես կարող էր փոխարինվել lambda-ով։ Ահա թե ինչու եզրակացրինք, որ այն տարբերակը, որն ուզում ենք ընտրել, Orchestrator-ն է, որը տիրապետում է ենթաբաղադրիչներին և կարող է հեշտությամբ փոխել նրանց ռեժիմները։

Այսպես թե այնպես, ReaderTaskConsumer-ը կարող էր գրեթե անխափան փոխարինվել lambda-ով, և մենք մտածում ենք ապագայում կատարել այդ փոփոխությունը։

Ամեն դեպքում, կուրախանայինք լսել ձեր գաղափարները այս ճարտարապետությունը բարելավելու կամ ամբողջ խնդիրը բոլորովին այլ կերպ լուծելու մասին։

Ծանոթագրություններ


  1. Հաջող սցենարում հաղորդագրությունը մշակում է միայն մեկ ReaderTaskConsumer։ Եթե ինչ-որ բան սխալ է ընթանում և VisibilityTimeout-ը լրանում է, մեկ այլ ինստանս կվերցնի այն, ուստի հաղորդագրությունները իրականում կարող են CacheQueue-ում հայտնվել մեկից ավելի անգամ։ Սերվիսը, այնուամենայնիվ, պետք է հնարավորինս ամեն ինչ անի՝ ամեն ինչ ուղարկելու ճիշտ մեկ անգամ, բայց առնվազն մեկ անգամ առաքման սկզբունքը առաջնահերթ է։ ↩
  2. Գործնականում տրամաբանությունը պետք է փոքր-ինչ տարբերվի այն պլանավորումների համար, որոնք շատ շուտով պետք է կրկնվեն։ Եթե հաջորդ փորձը ընկնում է հիմա-ից 15 րոպեի ընթացքում կամ ճիշտ այդ պահին (15 րոպեն SQS-ի աջակցած առավելագույն հետաձգումն է), դրանք անմիջապես դրվում են քեշում և պահպանվում DynamoDB-ում skip flag=true-ով։ Այդպես պլանավորումը միշտ պետք է հայտնվի քեշում, եթե դեռ պատկանում է նույն բաքեթին (օրինակ՝ հաջորդ փորձը 5 վայրկյանից է)։ Միևնույն ժամանակ, եթե այն տեղափոխվում է հաջորդ բաքեթ (օրինակ՝ հաջորդ փորձը 12 րոպե հետո է), այն չպետք է կրկնօրինակվի այդ հաջորդ բաքեթը մշակող ReaderTaskConsumer-ի կողմից, քանի որ սպառողը skip flag-ի հիման վրա զտում է նման պլանավորումը։ ↩
  3. SSM parameter store-ի պարամետրերը շրջանային են և «արկղից դուրս» չեն կրկնօրինակվում։ Ուստի գործնականում յուրաքանչյուր աջակցվող շրջան պետք է ունենա իր առանձին պարամետրը, որն օգտագործվում է այդ շրջանում աշխատող սերվիսի ինստանսների կողմից։ Շրջանային պարամետրերը պետք է համաժամեցված պահվեն միմյանց հետ։
    Բացի այդ, շրջաններից մեկը պետք է հստակ նշանակվի որպես failover-ի ստանձնող շրջան։ Դա կարելի է անել հենց պարամետրում կամ, որպես այլընտրանք, հավելվածի կոնֆիգուրացիայի ինչ-որ տեղ։
    Պարամետրերի արժեքների թարմացումը նույնպես կարելի է ավտոմատացնել իրադարձությունների վրա հիմնված մոտեցմամբ, որը նաև դրանք ավտոմատ կերպով համաժամեցված է պահում շրջանների միջև։ Սակայն ճարտարապետության այդ մասը դուրս է այս հոդվածի շրջանակից և այստեղ չի ընդգրկվում։ Մենք դիտարկում ենք միայն այն, ինչ տեղի է ունենում արժեքի փոփոխությունից և պլանավորիչի failover-ի մասին իմանալուց հետո։ ↩
  4. Այս լրացուցիչ ReaderTaskProducer ինստանսը սկսում է բոլոր անցյալ բաքեթներով անցնելով՝ օրինակ մի քանի օր առաջվանից մինչև հիմա, դրանցից յուրաքանչյուրի համար ReaderTasks ստեղծելու և քեշը լցնելու համար։ Սա նվազեցնում է ցանկացած պլանավորում կորցնելու ռիսկը, քանի որ ստանձնող շրջանը պետք է մշակի դրանք (եթե, օրինակ, failover-ը հենց սկզբից առաջացրել է SQS-ի խափանումը, խափանման և նրա հայտնաբերման միջև հասունացած պլանավորումները կարող են չուղարկվել մինչև շրջանի փոխարկման ավարտը)։ Ինչպես նշվել է, պլանավորման GSI-ը հեռացվում է հաջող ուղարկվելուց հետո, ուստի ստանձնող շրջանը նման գրառումները տվյալների բազայից չի ստանա։ ↩
  5. Երբ failover է տեղի ունենում և պլանավորումը «տեղափոխվում է» ստանձնող շրջան, այն դիտարկվում է այնպես, կարծես միշտ պատկանել է ստանձնող շրջանին, այսինքն՝ եթե կրկնության քաղաքականությունը կիրառվում է, հետագա առաքման փորձերը տեղի են ունենում այդ շրջանում (եթե այն նույնպես անհասանելի չդառնա)։ ↩
  6. Այստեղ կարելի է/պետք է հետաձգում մտցնել բաղադրիչները գործարկելուց առաջ՝ լրացուցիչ համոզվելու համար, որ ոչինչ երկու անգամ չի ուղարկվում։ Սա հատկապես կարևոր է նույն պլանավորումը գրեթե միաժամանակ մի քանի շրջաններից ուղարկվելու ռիսկը նվազեցնելու համար, քանի որ դա կարող է տվյալների անհամահունչություն առաջացնել։ Ինչպես նշված է պահանջների բաժնում, պլանավորումները սպասվածից ուշ առաքելը թույլատրելի է, երբ անհրաժեշտ է, ուստի շրջանի failover-ի/վերականգնման պատճառով մի քանի պլանավորման հետաձգումը մեզ համար ընդունելի է։ ↩ ↩