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

Ձեր ամբողջ համակարգը՝ որպես կոդ. GitOps-ի առաջին քայլերը

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

8 րոպե
DevOpsGitSystem as a Codegitops

Այսօր մենք հակված ենք ամեն ինչ արտահայտել կոդով, և դա անհիմն չէ. infrastructure as code-ը շատ առավելություններ է տալիս՝ հետևողականություն, մոդուլայնություն, պաշտպանություն մարդկային սխալներից, տարբերակների կառավարում և այլն։ Նույնը կարելի է ասել մյուս «ինչ-որ բան որպես կոդ» մոտեցումների մասին՝ configuration as code, pipelines as code և այլն։

Ինչը բնականաբար հարց է առաջացնում. կարելի՞ է ամբողջ համակարգը պահել որպես կոդ։

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

Ի՞նչ է GitOps-ը

Սովորաբար նման հարցի դեպքում պատասխան գտնելու ձևը ակնհայտ է. որոնել համացանցում և նայել մի քանի պատասխան.

GitOps-ը իրականացնում է infrastructure as code-ը՝ Git ռեպոզիտորիաները դիտարկելով որպես ճշմարտության միակ աղբյուր։

Բավական պարզ է։ Terraform-ի կոդը դնում ես git ռեպոզիտորիայում, և վերջ։

GitOps-ը օպերացիոն ֆրեյմվորք է, որը ծրագրերի մշակման DevOps-ի լավագույն պրակտիկաները՝ տարբերակների կառավարումը, համագործակցությունը, համապատասխանությունը և CI/CD գործիքները, տարածում է ինֆրաստրուկտուրայի ավտոմատացման վրա։

Բավական նման է, միայն թե հիմա արդեն պարտադիր է CI/CD-ն։

GitOps-ը հիմնվում է այն սկզբունքի վրա, որ Git-ը ճշմարտության միակ աղբյուրն է։

Սա շատ կարևոր է։ Ով երբևէ պահպանել է փաստաթղթավորում, գիտի, որ թերմոդինամիկայի երկրորդ օրենքն իրական է, և տիեզերքի էնտրոպիան անընդհատ աճում է։

Ծրագրավորողներն արդեն պահում են հավելվածի սկզբնական կոդը Git-ում. GitOps-ը այդ պրակտիկան տարածում է հավելվածի կոնֆիգուրացիայի, ինֆրաստրուկտուրայի և օպերացիոն ընթացակարգերի վրա։

Հիմա ավելի հետաքրքիր է դառնում. կոնֆիգուրացիան և ինֆրաստրուկտուրան (որպես կոդ) git-ում պահելը հեշտ է պատկերացնել, բայց… օպերացիոն ընթացակարգե՞րը։

Ուրեմն GitOps-ի մեկ ընդհանուր սահմանում ընդհանրապես չկա՞։ Իրականում կա։ Որոշ ժամանակ առաջ խոշոր խաղացողներ, օրինակ՝ GitHub-ը, Azure-ը և Amazon-ը (ի թիվս այլոց), Cloud Native Computing Foundation-ի շրջանակներում ստեղծեցին GitOps Working Group։ Այդ աշխատանքային խմբի աշխատանքի արդյունքը OpenGitops 1.0 սկզբունքների հրապարակումն էր։

Open GitOps 1.0

GitOps-ով կառավարվող համակարգը պետք է ունենա ցանկալի վիճակ, որը.

  1. Declarative
    GitOps-ով կառավարվող համակարգի ցանկալի վիճակը պետք է արտահայտված լինի դեկլարատիվ ձևով։
  2. Versioned and Immutable
    Ցանկալի վիճակը պահվում է այնպիսի պահոցում, որը ապահովում է անփոփոխելիություն և տարբերակավորում և պահպանում է տարբերակների ամբողջ պատմությունը։
  3. Pulled Automatically
    Ծրագրային գործակալները ցանկալի վիճակի նկարագրությունները աղբյուրից վերցնում են ինքնուրույն։
  4. Continuously Reconciled
    Ծրագրային գործակալները շարունակ հետևում են համակարգի իրական վիճակին և փորձում են այն հասցնել ցանկալի վիճակին։

Պարզ է, որ OpenGitOps-ը շատ ավելին է, քան ինֆրաստրուկտուրայի կոդը git-ում պահելը։

Եկեք ավելի մանրամասն քննարկենք յուրաքանչյուր սկզբունքը։

Declarative

Համակարգի դեկլարատիվ նկարագրությունը անջատում է ցանկալի վիճակը այն հասնելու եղանակից՝ հրամաններից, API կանչերից, սկրիպտներից և այլն։ Ըստ էության, մենք համակարգի մասին փաստեր ենք նշում, այլ ոչ թե ընթացակարգեր գրում։

Versioned and Immutable

Ցանկալի վիճակը պետք է գտնվի այնպիսի համակարգում, որը ապահովում է անփոփոխելիություն։ Այլ կերպ ասած, վիճակը մեկ անգամ ստեղծվելուց հետո այլևս չի կարող փոփոխվել։ Համակարգի վիճակը փոխելու համար ստեղծվում է նոր տարբերակ, իսկ նախորդը մնում է պատմության մեջ։ GitOps-ի «git»-ը ակնհայտորեն գալիս է համակարգի վիճակը git ռեպոզիտորիայում պահելուց։ Սակայն այս սկզբունքի համաձայն՝ կարող է օգտագործվել պահանջը բավարարող ցանկացած համակարգ, օրինակ՝ S3 bucket՝ միացված տարբերակավորմամբ։

Շատ դեպքերում ակնհայտ ընտրությունը git ռեպոզիտորիան է. կոմիտները անփոփոխելի են, և յուրաքանչյուր նոր կոմիտ նոր տարբերակ է ներկայացնում։

Pulled automatically

Սա հատուկ է Open GitOps-ին։ GitOps-ի սահմանումների մեծ մասը խոսում է միայն ցանկալի վիճակի պահպանման մասին։ Այս սկզբունքը պահանջում է «ինչ-որ բան»՝ կառավարվող համակարգի վրա աշխատող ծրագրային գործակալներ, որոնք ակտիվորեն հետևում են պահոցին և վերցնում են ամենանոր տարբերակը։ Արդյունքում, երբ այդպիսի համակարգը գործում է, կոմիտը վերջին քայլն է, որի մասին օպերատորը պետք է հոգա։ Վիճակը աշխատող համակարգին կիրառելն այլևս նրա գործը չէ։

Continuously Reconciled

Ինչպես նախորդ սկզբունքի դեպքում, ոչ ոք՝ այսինքն ոչ մի մարդ, չպետք է մտածի, թե երբ և ինչպես է ցանկալի վիճակը հասնում աշխատող համակարգին։ Ծրագրակազմը դա անում է ավտոմատ կերպով։ Սա նման է Kubernetes կլաստերի վարքին. pod-ի manifest-ը կիրառելը չի երաշխավորում, որ pod-ը կաշխատի, քանի որ դա կախված է այնպիսի գործոններից, ինչպիսիք են հասանելի ռեսուրսները, node selector-ը, affinity-ն և այլն։ Այդուհանդերձ, համակարգը ամեն ինչ կանի, որպեսզի բավարարի այն, ինչ խնդրել է օպերատորը։

Արժե՞ արդյոք օգտագործել GitOps

TL;DR – այո, արժե ;-)։
Եկեք անցնենք այս մոտեցման մի քանի առավելությունների միջով և տեսնենք, թե ինչպես է այն կարող հեշտացնել ծրագրավորողի աշխատանքը։

Git՝ որպես ճշմարտության միակ աղբյուր

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

GitOps-ը սա լուծում է. git ռեպոզիտորիայում պահվող ցանկալի վիճակը ոչ թե պարզապես համակարգի փաստաթղթավորումն է, այլ հենց համակարգի վիճակն է։ Ճշմարտության միակ աղբյուրի առավելությունների մասին հավանաբար կարելի է գիրք գրել, բայց դրանց մեծ մասը ինքնին պարզ է։

Git՝ որպես համակարգը կառավարելու միակ գործիք.

Քանի որ ցանկալի վիճակը ավտոմատ կերպով վերցվում և կիրառվում է աշխատող համակարգին, ծրագրավորողից պահանջվում է միայն կոմիտ անել և փոփոխությունները push անել git ռեպոզիտորիա։ Նոր գործիքներ սովորելու կարիք չկա. իսկ որպես ծրագրավորող՝ git-ն արդեն գիտեք, չէ՞։

Համակարգի պատմությունը

Սովորաբար կարևոր է իմանալ ոչ միայն համակարգի ընթացիկ վիճակը, այլև թե ինչ տեսք է այն ունեցել նախկինում՝ ընդհանրապես նրա պատմությունը։ Սա առավել կարևոր է, երբ ինչ-որ բան կոտրվում է, և օպերատորը պետք է պարզի, թե ինչ է փոխվել։ Մի խոսքով, git ռեպոզիտորիան տալիս է համակարգի լիարժեք աուդիտի հնարավորություն։

(Համեմատաբար) հեշտ rollback

Վերը նշվածի կարևոր հետևանքը. ի՞նչ անել, երբ իսկապես ինչ-որ բան սխալ է ընթանում։ Չէ՞ որ սա կոդ է։ Իսկ ինչպե՞ս են ծրագրավորողները կոդը վերադարձնում նախկին վիճակի։ Իհարկե, git revert-ով։

Սովորաբար սա աշխատում է նաև ամբողջ համակարգի համար։ Եթե, ասենք, չի եղել տվյալների բազայի միգրացիա. առանց վիճակի (stateless) սերվիսների համար այն աշխատում է առանց որևէ խնդրի։

PR-ներ և կոդի վերանայում

Մենք ստանում ենք նույն գործիքները, ինչ կոդի հետ աշխատող մյուս բոլոր ծրագրավորողները։ Կարող ենք բացել PR-ներ, խնդրել կոդի վերանայում, գործարկել ավտոմատ CI թեստեր՝ ակնհայտ շարահյուսական սխալները բռնելու համար և այլն։ Սա զգալիորեն բարձրացնում է կառավարվող համակարգի հուսալիությունը և անվտանգությունը։

Աղետից վերականգնում

Ի՞նչ կլինի, եթե տվյալների կենտրոնին իսկապես աղետ պատահի։

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

Բայց եթե տվյալները պահուստավորված են, ամբողջ համակարգը այլ տեղում վերակառուցելը րոպեների հարց է։ Ճիշտ նույն սերվիսները, ճիշտ նույն տարբերակներով։

Հնարավոր խնդիրներ

GitOps-ը, իհարկե, աշխարհի բոլոր խնդիրների բուժիչը չէ։ Եկեք դիտարկենք GitOps-ի որոշ հնարավոր թակարդներ (և դրանց հաղթահարման ուղիներ)։

Մի քանի միջավայր

Համակարգի համար մի քանի միջավայր ունենալը՝ dev, staging, uat, production և այլն, այսօր ստանդարտ պրակտիկա է։

Ինչպե՞ս դա անել GitOps-ով։ Մեկ լավագույն պրակտիկա չկա։ Որոշ թիմեր օգտագործում են մի քանի ճյուղ, մյուսները՝ պարզապես git-ում մի քանի թղթապանակ, երրորդները՝ պարզապես մի քանի ռեպոզիտորիա։ Յուրաքանչյուր մոտեցում ունի առավելություններ և թերություններ, ուստի արժե փորձարկել։ Երբ GitOps-ը համակցվում է Kubernetes-ի հետ, արժե օգտագործել Customization, որը օգնում է կոդը պահել DRY։

Գաղտնիքներ

GitOps-ը պահանջում է ամեն ինչ պահել git ռեպոզիտորիայում, սակայն, ինչպես շատերը գիտեն, գաղտնիքները (credentials) git-ում գաղտնագրված պահելը շատ վատ գաղափար է, նույնիսկ մասնավոր ռեպոզիտորիայում։

Դրա շուրջով անցնելու մի քանի եղանակ կա։ Որոշ գործիքներ, օրինակ՝ Bitnami SealedScrets-ը կամ KOPS-ը, թույլ են տալիս գաղտնիքները գաղտնագրված պահել git-ում և ավտոմատ կերպով վերծանել կլաստերում։ Մյուսները գաղտնիքները պարզապես git-ից դուրս են պահում և միայն հղում են անում ուրիշ տեղ պահվող գաղտնիքներին. հիմնական օրինակը External Secrets operator-ն է։

Տեխնիկական մասի համար հեշտ է, բիզնեսի համար՝ դժվար

Git-ը բոլորը գիտեն և օգտագործում են։ Դե, յուրաքանչյուր տեխնիկական մարդ՝ այո։ Երբ բիզնես կողմից որևէ մեկը տալիս է սովորական հարցը՝ «ո՞ր տարբերակը և ո՞ր ֆունկցիաներն են հիմա production-ում», «կարող եք նայել GitHub-ում» պատասխանը հավանաբար նրան չի բավարարի։

Սա մեզ մղում է ստեղծել լրացուցիչ գործիքներ, որոնք git ռեպոզիտորիան «թարգմանում» են ոչ տեխնիկական մարդկանց համար հեշտ ընթեռնելի տեսքի։

OpenGitops 1.0-ի իրականացումները

Open GitOps սկզբունքները իրականացնող երկու ամենակարևոր գործիքները հավանաբար FluxCD-ն և ArgoCD-ն են (գուցե կան նաև այլ գործիքներ, բայց այս երկուսը, հավանաբար, ամենահայտնին են)։

Ո՞րն է ավելի լավը։ Ո՞րը ընտրել։ Ինչպես ցանկացած նման հարցի դեպքում, պատասխանը մեկն է. կախված է։ Երկուսն էլ ունեն գերազանց փաստաթղթավորում և quick-start ուղեցույցներ, որոնք հեշտացնում են դրանց հետ ծանոթանալը։

Բազմաթիվ հոդվածներ և տեսանյութեր համեմատում են այս երկուսը. խորհուրդ եմ տալիս դրանց ծանոթանալ։

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

FluxCD-ն, մյուս կողմից, ունի բազմաթիվ controller-ներ և բազմաթիվ CRD-ներ, որոնք՝ իմ խոնարհ կարծիքով, ավելի մոտ են համապատասխանում իր կառավարած օբյեկտներին։

ArgoCD-ի գլխավոր առավելությունը նրա գրաֆիկական օգտատիրական ինտերֆեյսն է, ինչի պատճառով ծրագրավորողները, հավանաբար, ընտրում են հենց այն։

Ամփոփում

Եթե ձեր նախագիծը դեռ չի օգտագործում GitOps, անկեղծորեն կարծում եմ, որ պետք է օգտագործի։ Այն կյանքը շատ ավելի պարզ է դարձնում, հատկապես Kubernetes-ի հետ համատեղ։ Որքան մեծ է նախագիծը, այնքան ավելի դժվար է դառնում դրա բոլոր մասերը վերահսկողության տակ պահել։ Կարող եք սկսել փոքրից՝ համակարգի միայն մի մասից, և տեսնել՝ արդյոք այն ձեզ հարմար է։ Բավական վստահ եմ, որ դուք կսիրեք այն 🙂։