Ձեր ամբողջ համակարգը՝ որպես կոդ. GitOps-ի առաջին քայլերը
Այսօր մենք ուզում ենք ամեն ինչ արտահայտել կոդով, բայց կարելի՞ է այդպես նկարագրել ամբողջ համակարգը։ Կարելի է։ Իմացեք, թե ինչ է GitOps-ը և ինչպես կարող է այն հեշտացնել ձեր աշխատանքը։
Այսօր մենք հակված ենք ամեն ինչ արտահայտել կոդով, և դա անհիմն չէ. 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-ով կառավարվող համակարգը պետք է ունենա ցանկալի վիճակ, որը.
- Declarative
GitOps-ով կառավարվող համակարգի ցանկալի վիճակը պետք է արտահայտված լինի դեկլարատիվ ձևով։ - Versioned and Immutable
Ցանկալի վիճակը պահվում է այնպիսի պահոցում, որը ապահովում է անփոփոխելիություն և տարբերակավորում և պահպանում է տարբերակների ամբողջ պատմությունը։ - Pulled Automatically
Ծրագրային գործակալները ցանկալի վիճակի նկարագրությունները աղբյուրից վերցնում են ինքնուրույն։ - 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-ի հետ համատեղ։ Որքան մեծ է նախագիծը, այնքան ավելի դժվար է դառնում դրա բոլոր մասերը վերահսկողության տակ պահել։ Կարող եք սկսել փոքրից՝ համակարգի միայն մի մասից, և տեսնել՝ արդյոք այն ձեզ հարմար է։ Բավական վստահ եմ, որ դուք կսիրեք այն 🙂։