OpenShift માટે GitOps નો પરિચય

આજે આપણે GitOps ના સિદ્ધાંતો અને મોડેલો વિશે વાત કરીશું, તેમજ આ મોડલ્સને OpenShift પ્લેટફોર્મ પર કેવી રીતે લાગુ કરવામાં આવે છે. આ વિષય પર એક ઇન્ટરેક્ટિવ માર્ગદર્શિકા ઉપલબ્ધ છે લિંક.

ટૂંકમાં, GitOps એ ઇન્ફ્રાસ્ટ્રક્ચર અને એપ્લિકેશન ગોઠવણીઓનું સંચાલન કરવા માટે Git પુલ વિનંતીઓનો ઉપયોગ કરવા માટેની પ્રેક્ટિસનો સમૂહ છે. GitOps માં Git રિપોઝીટરીને સિસ્ટમની સ્થિતિ વિશે માહિતીના એક સ્ત્રોત તરીકે ગણવામાં આવે છે, અને આ સ્થિતિમાં કોઈપણ ફેરફારો સંપૂર્ણપણે શોધી શકાય છે અને ઑડિટેબલ છે.

GitOps માં પરિવર્તન ટ્રેકિંગનો વિચાર કોઈ પણ રીતે નવો નથી; એપ્લિકેશન સોર્સ કોડ સાથે કામ કરતી વખતે આ અભિગમ લાંબા સમયથી લગભગ સાર્વત્રિક રીતે ઉપયોગમાં લેવાય છે. GitOps ઇન્ફ્રાસ્ટ્રક્ચર અને એપ્લિકેશન કન્ફિગરેશન મેનેજમેન્ટમાં સમાન સુવિધાઓ (સમીક્ષાઓ, પુલ વિનંતીઓ, ટૅગ્સ, વગેરે) નો અમલ કરે છે અને સ્રોત કોડ મેનેજમેન્ટના કિસ્સામાં સમાન લાભો પ્રદાન કરે છે.

GitOps માટે કોઈ શૈક્ષણિક વ્યાખ્યા અથવા મંજૂર નિયમો નથી, ફક્ત સિદ્ધાંતોનો સમૂહ કે જેના પર આ પ્રથા બનાવવામાં આવી છે:

• સિસ્ટમનું ઘોષણાત્મક વર્ણન ગિટ રિપોઝીટરી (રૂપરેખાઓ, મોનીટરીંગ, વગેરે) માં સંગ્રહિત છે.
• પુલ વિનંતીઓ દ્વારા રાજ્ય ફેરફારો કરવામાં આવે છે.
• Git પુશ વિનંતીઓનો ઉપયોગ કરીને ચાલતી સિસ્ટમોની સ્થિતિને રીપોઝીટરીમાંના ડેટા સાથે વાક્યમાં લાવવામાં આવે છે.

GitOps સિદ્ધાંતો

• સિસ્ટમ વ્યાખ્યાઓ સ્ત્રોત કોડ તરીકે વર્ણવવામાં આવે છે

સિસ્ટમ રૂપરેખાંકનને કોડ તરીકે ગણવામાં આવે છે જેથી તે ગિટ રિપોઝીટરીમાં સંગ્રહિત અને આપમેળે સંસ્કરણ થઈ શકે, જે સત્યના એક સ્ત્રોત તરીકે સેવા આપે છે. આ અભિગમ સિસ્ટમોમાં રોલઆઉટ અને રોલબેક ફેરફારોને સરળ બનાવે છે.

• સિસ્ટમોની ઇચ્છિત સ્થિતિ અને રૂપરેખાંકન Git માં સેટ અને સંસ્કરણ થયેલ છે

ગિટમાં સિસ્ટમ્સની ઇચ્છિત સ્થિતિને સ્ટોર કરીને અને વર્ઝન કરીને, અમે સિસ્ટમ્સ અને એપ્લિકેશન્સમાં ફેરફારોને સરળતાથી રોલ આઉટ અને રોલ બેક કરવામાં સક્ષમ છીએ. અમે કોડની માલિકીનું નિયંત્રણ કરવા અને તેની અધિકૃતતા ચકાસવા માટે Gitની સુરક્ષા પદ્ધતિઓનો પણ ઉપયોગ કરી શકીએ છીએ.

• રૂપરેખાંકન ફેરફારો પુલ વિનંતીઓ દ્વારા આપમેળે લાગુ થઈ શકે છે

Git પુલ વિનંતીઓનો ઉપયોગ કરીને, અમે સરળતાથી નિયંત્રિત કરી શકીએ છીએ કે કેવી રીતે રીપોઝીટરીમાં રૂપરેખાંકનો પર ફેરફારો લાગુ કરવામાં આવે છે. ઉદાહરણ તરીકે, તેઓ ટીમના અન્ય સભ્યોને સમીક્ષા માટે આપી શકાય છે અથવા CI પરીક્ષણો વગેરે દ્વારા ચલાવવામાં આવી શકે છે.

અને તે જ સમયે, એડમિન સત્તાઓને ડાબે અને જમણે વિતરિત કરવાની જરૂર નથી. રૂપરેખાંકન ફેરફારો કરવા માટે, વપરાશકર્તાઓને માત્ર Git રિપોઝીટરીમાં યોગ્ય પરવાનગીઓની જરૂર છે જ્યાં તે રૂપરેખાંકનો સંગ્રહિત છે.

• રૂપરેખાંકનોના અનિયંત્રિત ડ્રિફ્ટની સમસ્યાને ઠીક કરવી

એકવાર સિસ્ટમની ઇચ્છિત સ્થિતિ ગિટ રિપોઝીટરીમાં સંગ્રહિત થઈ જાય, પછી આપણે ફક્ત સોફ્ટવેર શોધવાનું છે જે ખાતરી કરશે કે સિસ્ટમની વર્તમાન સ્થિતિ તેની ઇચ્છિત સ્થિતિ સાથે મેળ ખાય છે. જો આ કિસ્સો ન હોય, તો આ સૉફ્ટવેર - સેટિંગ્સ પર આધાર રાખીને - કાં તો તેની પોતાની રીતે વિસંગતતાને દૂર કરે છે, અથવા રૂપરેખાંકન ડ્રિફ્ટ વિશે અમને સૂચિત કરે છે.

OpenShift માટે GitOps મોડલ્સ

ઑન-ક્લસ્ટર રિસોર્સ રિકોન્સિલર

આ મોડેલ મુજબ, ક્લસ્ટરમાં એક નિયંત્રક છે જે ક્લસ્ટરના વાસ્તવિક સંસાધનો સાથે ગિટ રિપોઝીટરીમાં કુબરનેટ્સ સંસાધનો (YAML ફાઇલો) ની સરખામણી કરવા માટે જવાબદાર છે. જો વિસંગતતાઓ મળી આવે, તો નિયંત્રક સૂચનાઓ મોકલે છે અને સંભવતઃ વિસંગતતાઓને સુધારવા માટે પગલાં લે છે. આ GitOps મોડલનો ઉપયોગ એન્થોસ કોન્ફિગ મેનેજમેન્ટ અને વેવવર્કસ ફ્લક્સમાં થાય છે.

બાહ્ય સંસાધન સમાધાનકર્તા (પુશ)

આ મોડેલને પાછલા એકની વિવિધતા તરીકે ગણી શકાય, જ્યારે અમારી પાસે "ગીટ રિપોઝીટરી - કુબરનેટ્સ ક્લસ્ટર" જોડીઓમાં સંસાધનોને સિંક્રનાઇઝ કરવા માટે જવાબદાર એક અથવા વધુ નિયંત્રકો હોય. અહીં તફાવત એ છે કે દરેક સંચાલિત ક્લસ્ટર પાસે તેનું પોતાનું અલગ નિયંત્રક હોવું જરૂરી નથી. Git - k8s ક્લસ્ટર જોડીઓને ઘણીવાર CRDs (કસ્ટમ રિસોર્સ ડેફિનેશન) તરીકે વ્યાખ્યાયિત કરવામાં આવે છે, જે વર્ણવી શકે છે કે કંટ્રોલરે સિંક્રોનાઇઝેશન કેવી રીતે કરવું જોઈએ. આ મોડેલની અંદર, નિયંત્રકો CRDમાં ઉલ્લેખિત ગિટ રિપોઝીટરીની સરખામણી કુબરનેટ્સ ક્લસ્ટર સંસાધનો સાથે કરે છે, જે CRDમાં પણ ઉલ્લેખિત છે, અને સરખામણીના પરિણામોના આધારે યોગ્ય ક્રિયાઓ કરે છે. ખાસ કરીને, આ GitOps મોડલનો ઉપયોગ ArgoCD માં થાય છે.

OpenShift પ્લેટફોર્મ પર GitOps

મલ્ટિ-ક્લસ્ટર કુબરનેટ્સ ઈન્ફ્રાસ્ટ્રક્ચરનું સંચાલન

કુબરનેટ્સના ફેલાવા સાથે અને મલ્ટિ-ક્લાઉડ વ્યૂહરચના અને એજ કમ્પ્યુટિંગની વધતી જતી લોકપ્રિયતા સાથે, ગ્રાહક દીઠ ઓપનશિફ્ટ ક્લસ્ટરોની સરેરાશ સંખ્યા પણ વધી રહી છે.

ઉદાહરણ તરીકે, એજ કમ્પ્યુટિંગનો ઉપયોગ કરતી વખતે, એક ગ્રાહકના ક્લસ્ટરને સેંકડો અથવા તો હજારોમાં જમાવી શકાય છે. પરિણામે, તેને પબ્લિક ક્લાઉડ અને ઓન-પ્રિમાઈસમાં ઘણા સ્વતંત્ર અથવા સંકલિત ઓપનશિફ્ટ ક્લસ્ટરનું સંચાલન કરવાની ફરજ પડી છે.

આ કિસ્સામાં, ઘણી સમસ્યાઓ હલ કરવી પડશે, ખાસ કરીને:

• કંટ્રોલ કરો કે ક્લસ્ટર્સ સમાન સ્થિતિમાં છે (રૂપરેખા, મોનિટરિંગ, સ્ટોરેજ, વગેરે.)
• જાણીતી સ્થિતિના આધારે ક્લસ્ટરોને ફરીથી બનાવો (અથવા પુનઃસ્થાપિત કરો).
• જાણીતી સ્થિતિના આધારે નવા ક્લસ્ટરો બનાવો.
• બહુવિધ OpenShift ક્લસ્ટરોમાં ફેરફારોને રોલ આઉટ કરો.
• બહુવિધ OpenShift ક્લસ્ટરોમાં ફેરફારોને પાછા ફરો.
• ટેમ્પલેટેડ રૂપરેખાંકનોને વિવિધ વાતાવરણ સાથે લિંક કરો.

એપ્લિકેશન રૂપરેખાંકનો

તેમના જીવનચક્ર દરમિયાન, એપ્લિકેશન ઘણીવાર ઉત્પાદન ક્લસ્ટરમાં સમાપ્ત થતાં પહેલાં ક્લસ્ટરોની સાંકળ (દેવ, સ્ટેજ, વગેરે)માંથી પસાર થાય છે. વધુમાં, પ્રાપ્યતા અને માપનીયતાની આવશ્યકતાઓને લીધે, ગ્રાહકો ઘણીવાર બહુવિધ ઓન-પ્રિમાઈસ ક્લસ્ટરો અથવા સાર્વજનિક ક્લાઉડ પ્લેટફોર્મના બહુવિધ પ્રદેશોમાં એપ્લિકેશનો જમાવે છે.

આ કિસ્સામાં, નીચેના કાર્યોને હલ કરવાની જરૂર છે:

• ક્લસ્ટરો (દેવ, સ્ટેજ, વગેરે) વચ્ચે એપ્લિકેશન્સ (દ્વિસંગી, રૂપરેખાઓ, વગેરે) ની હિલચાલની ખાતરી કરો.
• કેટલાક OpenShift ક્લસ્ટરોમાં એપ્લિકેશનો (દ્વિસંગી, રૂપરેખાઓ, વગેરે) માં ફેરફારોને રોલ આઉટ કરો.
• પાછલી જાણીતી સ્થિતિમાં એપ્લિકેશન્સમાં ફેરફારોને રોલ બેક કરો.

OpenShift GitOps ઉપયોગના કેસો

1. Git રીપોઝીટરીમાંથી ફેરફારો લાગુ કરી રહ્યા છીએ

ક્લસ્ટર એડમિનિસ્ટ્રેટર ઓપનશિફ્ટ ક્લસ્ટર કન્ફિગરેશનને ગિટ રિપોઝીટરીમાં સ્ટોર કરી શકે છે અને તેને નવા ક્લસ્ટરો બનાવવા માટે આપમેળે લાગુ કરી શકે છે અને ગિટ રિપોઝીટરીમાં સ્ટોર કરેલી જાણીતી સ્થિતિની સમાન સ્થિતિમાં લાવી શકે છે.

2. સિક્રેટ મેનેજર સાથે સિંક્રનાઇઝેશન

એડમિનિસ્ટ્રેટરને આ માટે ખાસ બનાવેલા ટૂલ્સનો ઉપયોગ કરીને તેનું સંચાલન કરવા માટે Vault જેવા યોગ્ય સૉફ્ટવેર સાથે OpenShift સિક્રેટ ઑબ્જેક્ટ્સને સિંક્રનાઇઝ કરવાની ક્ષમતાથી પણ ફાયદો થશે.

3. ડ્રિફ્ટ રૂપરેખાંકનોનું નિયંત્રણ

એડમિન ફક્ત ત્યારે જ તરફેણમાં રહેશે જો OpenShift GitOps પોતે વાસ્તવિક રૂપરેખાંકનો અને રિપોઝીટરીમાં ઉલ્લેખિત વચ્ચેની વિસંગતતાઓને ઓળખે અને ચેતવણી આપે, જેથી તેઓ ઝડપથી ડ્રિફ્ટનો જવાબ આપી શકે.

4. રૂપરેખાંકન ડ્રિફ્ટ વિશે સૂચનાઓ

તેઓ એવા કિસ્સામાં ઉપયોગી છે જ્યારે એડમિનિસ્ટ્રેટર ઝડપથી યોગ્ય પગલાં લેવા માટે રૂપરેખાંકન ડ્રિફ્ટના કેસો વિશે ઝડપથી જાણવા માંગે છે.

5. ડ્રિફ્ટિંગ વખતે રૂપરેખાંકનોનું મેન્યુઅલ સિંક્રનાઇઝેશન

એડમિનને રૂપરેખાંકન ડ્રિફ્ટની ઘટનામાં ઓપનશિફ્ટ ક્લસ્ટરને Git રિપોઝીટરી સાથે સિંક્રનાઇઝ કરવાની મંજૂરી આપે છે, ક્લસ્ટરને અગાઉની જાણીતી સ્થિતિમાં ઝડપથી પરત કરવા માટે.

6. ડ્રિફ્ટિંગ વખતે રૂપરેખાંકનોનું સ્વતઃ-સિંક્રોનાઇઝેશન

જ્યારે ડ્રિફ્ટ શોધાય છે ત્યારે એડમિનિસ્ટ્રેટર ઓપનશિફ્ટ ક્લસ્ટરને રિપોઝીટરી સાથે આપમેળે સિંક્રનાઇઝ કરવા માટે પણ ગોઠવી શકે છે, જેથી ક્લસ્ટર કન્ફિગરેશન હંમેશા ગિટમાંના રૂપરેખાઓ સાથે મેળ ખાય.

7. કેટલાક ક્લસ્ટરો - એક ભંડાર

એડમિનિસ્ટ્રેટર એક ગિટ રિપોઝીટરીમાં વિવિધ ઓપનશિફ્ટ ક્લસ્ટરોની રૂપરેખાંકનો સંગ્રહિત કરી શકે છે અને જરૂરિયાત મુજબ તેમને પસંદગીપૂર્વક લાગુ કરી શકે છે.

8. ક્લસ્ટર ગોઠવણીનો વંશવેલો (વારસો)

એડમિન રિપોઝીટરીમાં ક્લસ્ટર કન્ફિગરેશનનો વંશવેલો સેટ કરી શકે છે (વારસા સાથે સ્ટેજ, પ્રોડ, એપ પોર્ટફોલિયો વગેરે). બીજા શબ્દોમાં કહીએ તો, તે નક્કી કરી શકે છે કે રૂપરેખાંકનો એક અથવા વધુ ક્લસ્ટરો પર લાગુ કરવા જોઈએ.

ઉદાહરણ તરીકે, જો એડમિનિસ્ટ્રેટર ગિટ રિપોઝીટરીમાં "પ્રોડક્શન ક્લસ્ટરો (પ્રોડ) → સિસ્ટમ X ક્લસ્ટર્સ → સિસ્ટમ Xના પ્રોડક્શન ક્લસ્ટર્સ" વંશવેલો સેટ કરે છે, તો પછી નીચેની રૂપરેખાઓનું સંયોજન સિસ્ટમ X ના ઉત્પાદન ક્લસ્ટરો પર લાગુ થાય છે:

• બધા ઉત્પાદન ક્લસ્ટરો માટે સામાન્ય રૂપરેખાઓ.
• સિસ્ટમ X ક્લસ્ટર માટે રૂપરેખાંકનો.
• X સિસ્ટમ ઉત્પાદન ક્લસ્ટર માટે રૂપરેખાઓ.

9. નમૂનાઓ અને રૂપરેખાંકન ઓવરરાઇડ્સ

એડમિનિસ્ટ્રેટર વારસાગત રૂપરેખાંકનો અને તેમના મૂલ્યોના સમૂહને ઓવરરાઇડ કરી શકે છે, ઉદાહરણ તરીકે, ચોક્કસ ક્લસ્ટરો માટે રૂપરેખાંકનને ફાઇન-ટ્યુન કરવા માટે કે જેના પર તેઓ લાગુ કરવામાં આવશે.

10. રૂપરેખાંકનો, એપ્લિકેશન રૂપરેખાંકનો માટે પસંદગીયુક્ત સમાવેશ અને બાકાત

એડમિનિસ્ટ્રેટર એપ્લીકેશન માટે શરતો સેટ કરી શકે છે અથવા અમુક રૂપરેખાંકનોને અમુક લાક્ષણિકતાઓવાળા ક્લસ્ટરો માટે બિન-એપ્લીકેશન કરી શકે છે.

11. ટેમ્પલેટ સપોર્ટ

વિકાસકર્તાઓને દરેક ચોક્કસ એપ્લિકેશન માટે સૌથી યોગ્ય ફોર્મેટનો ઉપયોગ કરવા માટે એપ્લિકેશન સંસાધનોને કેવી રીતે વ્યાખ્યાયિત કરવામાં આવશે તે પસંદ કરવાની ક્ષમતાથી લાભ થશે (હેલ્મ ચાર્ટ, શુદ્ધ કુબરનેટ્સ યામલ, વગેરે.).

OpenShift પ્લેટફોર્મ પર GitOps ટૂલ્સ

આર્ગોસીડી

આર્ગોસીડી બાહ્ય સંસાધન રીકોન્સાઈલ મોડલનો અમલ કરે છે અને ક્લસ્ટરો અને ગિટ રિપોઝીટરીઝ વચ્ચે એક-થી-ઘણા સંબંધોને ગોઠવવા માટે કેન્દ્રિય UI ઓફર કરે છે. આ પ્રોગ્રામના ગેરફાયદામાં જ્યારે ArgoCD કામ ન કરતી હોય ત્યારે એપ્લિકેશનનું સંચાલન કરવામાં અસમર્થતાનો સમાવેશ થાય છે.

સત્તાવાર વેબસાઇટ

પ્રવાહ

ફ્લક્સ ઓન-ક્લસ્ટર રિસોર્સ રિકોન્સાઈલ મોડલનો અમલ કરે છે અને પરિણામે, ડેફિનેશન રિપોઝીટરીનું કોઈ કેન્દ્રિય સંચાલન નથી, જે એક નબળો મુદ્દો છે. બીજી બાજુ, કેન્દ્રીયકરણના અભાવને કારણે, એક ક્લસ્ટર નિષ્ફળ જાય તો પણ એપ્લિકેશનનું સંચાલન કરવાની ક્ષમતા રહે છે.

સત્તાવાર વેબસાઇટ

OpenShift પર ArgoCD ઇન્સ્ટોલ કરી રહ્યું છે

ArgoCD એક ઉત્તમ કમાન્ડ લાઇન ઇન્ટરફેસ અને વેબ કન્સોલ પ્રદાન કરે છે, તેથી અમે અહીં ફ્લક્સ અને અન્ય વિકલ્પોને આવરીશું નહીં.

OpenShift 4 પ્લેટફોર્મ પર ArgoCD જમાવવા માટે, ક્લસ્ટર એડમિનિસ્ટ્રેટર તરીકે આ પગલાં અનુસરો:

OpenShift પ્લેટફોર્મ પર ArgoCD ઘટકોનો ઉપયોગ

# Create a new namespace for ArgoCD components
oc create namespace argocd
# Apply the ArgoCD Install Manifest
oc -n argocd apply -f https://raw.githubusercontent.com/argoproj/argo-cd/v1.2.2/manifests/install.yaml
# Get the ArgoCD Server password
ARGOCD_SERVER_PASSWORD=$(oc -n argocd get pod -l "app.kubernetes.io/name=argocd-server" -o jsonpath='{.items[*].metadata.name}')

આર્ગોસીડી સર્વરનો સુધારો જેથી તે ઓપનશિફ્ટ રૂટ દ્વારા જોઈ શકાય

# Patch ArgoCD Server so no TLS is configured on the server (--insecure)
PATCH='{"spec":{"template":{"spec":{"$setElementOrder/containers":[{"name":"argocd-server"}],"containers":[{"command":["argocd-server","--insecure","--staticassets","/shared/app"],"name":"argocd-server"}]}}}}'
oc -n argocd patch deployment argocd-server -p $PATCH
# Expose the ArgoCD Server using an Edge OpenShift Route so TLS is used for incoming connections
oc -n argocd create route edge argocd-server --service=argocd-server --port=http --insecure-policy=Redirect

ArgoCD Cli ટૂલ જમાવી રહ્યું છે

# Download the argocd binary, place it under /usr/local/bin and give it execution permissions
curl -L https://github.com/argoproj/argo-cd/releases/download/v1.2.2/argocd-linux-amd64 -o /usr/local/bin/argocd
chmod +x /usr/local/bin/argocd

ArgoCD સર્વર એડમિન પાસવર્ડ બદલવો

# Get ArgoCD Server Route Hostname
ARGOCD_ROUTE=$(oc -n argocd get route argocd-server -o jsonpath='{.spec.host}')
# Login with the current admin password
argocd --insecure --grpc-web login ${ARGOCD_ROUTE}:443 --username admin --password ${ARGOCD_SERVER_PASSWORD}
# Update admin's password
argocd --insecure --grpc-web --server ${ARGOCD_ROUTE}:443 account update-password --current-password ${ARGOCD_SERVER_PASSWORD} --new-password

આ પગલાંઓ પૂર્ણ કર્યા પછી, તમે ArgoCD WebUI વેબ કન્સોલ અથવા ArgoCD Cli કમાન્ડ લાઇન ટૂલ દ્વારા ArgoCD સર્વર સાથે કામ કરી શકો છો.
https://blog.openshift.com/is-it-too-late-to-integrate-gitops/

GitOps - તે ક્યારેય મોડું થતું નથી

"ટ્રેન નીકળી ગઈ છે" - આ તેઓ એવી પરિસ્થિતિ વિશે કહે છે જ્યારે કંઈક કરવાની તક ચૂકી જાય છે. OpenShift ના કિસ્સામાં, આ શાનદાર નવા પ્લેટફોર્મનો ઉપયોગ તરત જ શરૂ કરવાની ઇચ્છા ઘણી વખત રૂટ્સ, ડિપ્લોયમેન્ટ્સ અને અન્ય OpenShift ઑબ્જેક્ટ્સના સંચાલન અને જાળવણી સાથે બરાબર આ પરિસ્થિતિનું સર્જન કરે છે. પરંતુ શું તક હંમેશા સંપૂર્ણપણે ચૂકી જાય છે?

વિશે લેખોની શ્રેણી ચાલુ રાખવી ગીટોપ્સ, આજે અમે તમને બતાવીશું કે કેવી રીતે હાથથી બનાવેલ એપ્લિકેશન અને તેના સંસાધનોને એક પ્રક્રિયામાં રૂપાંતરિત કરવું જ્યાં બધું GitOps ટૂલ્સ દ્વારા સંચાલિત થાય છે. આ કરવા માટે, અમે પહેલા httpd એપ્લિકેશનને મેન્યુઅલી જમાવીશું. નીચેનો સ્ક્રીનશોટ બતાવે છે કે આપણે કેવી રીતે નેમસ્પેસ, ડિપ્લોયમેન્ટ અને સર્વિસ બનાવીએ છીએ અને પછી રૂટ બનાવવા માટે આ સર્વિસને એક્સપોઝ કરીએ છીએ.

oc create -f https://raw.githubusercontent.com/openshift/federation-dev/master/labs/lab-4-assets/namespace.yaml
oc create -f https://raw.githubusercontent.com/openshift/federation-dev/master/labs/lab-4-assets/deployment.yaml
oc create -f https://raw.githubusercontent.com/openshift/federation-dev/master/labs/lab-4-assets/service.yaml
oc expose svc/httpd -n simple-app

તેથી અમારી પાસે હસ્તકલા એપ્લિકેશન છે. હવે તેને GitOps મેનેજમેન્ટ હેઠળ ઉપલબ્ધતા ગુમાવ્યા વિના ટ્રાન્સફર કરવાની જરૂર છે. ટૂંકમાં, તે આ કરે છે:

• કોડ માટે ગિટ રીપોઝીટરી બનાવો.
• અમે અમારા વર્તમાન ઑબ્જેક્ટ્સને નિકાસ કરીએ છીએ અને તેમને Git રિપોઝીટરીમાં અપલોડ કરીએ છીએ.
• GitOps ટૂલ્સ પસંદ અને જમાવવું.
• અમે આ ટૂલકીટમાં અમારી રીપોઝીટરી ઉમેરીએ છીએ.
• અમે અમારી GitOps ટૂલકીટમાં એપ્લિકેશનને વ્યાખ્યાયિત કરીએ છીએ.
• અમે GitOps ટૂલકીટનો ઉપયોગ કરીને એપ્લિકેશનનો ટેસ્ટ રન કરીએ છીએ.
• અમે GitOps ટૂલકીટનો ઉપયોગ કરીને ઑબ્જેક્ટ્સને સિંક્રનાઇઝ કરીએ છીએ.
• ઑબ્જેક્ટની કાપણી અને ઑટો-સિંક્રોનાઇઝેશનને સક્ષમ કરો.

અગાઉ ઉલ્લેખ કર્યો છે લેખ, GitOps માં કુબરનેટ્સ ક્લસ્ટર(ઓ) માં તમામ ઑબ્જેક્ટ્સ વિશે માહિતીનો એક અને માત્ર એક જ સ્ત્રોત છે - ગિટ રિપોઝીટરી. આગળ, અમે એ આધારથી આગળ વધીએ છીએ કે તમારી સંસ્થા પહેલેથી જ ગિટ રિપોઝીટરીનો ઉપયોગ કરે છે. તે સાર્વજનિક અથવા ખાનગી હોઈ શકે છે, પરંતુ તે કુબરનેટ્સ ક્લસ્ટરો માટે સુલભ હોવું જોઈએ. આ એપ્લીકેશન કોડ માટે સમાન રીપોઝીટરી હોઈ શકે છે અથવા ખાસ કરીને જમાવટ માટે બનાવેલ અલગ રીપોઝીટરી હોઈ શકે છે. રિપોઝીટરીમાં કડક પરવાનગીઓ રાખવાની ભલામણ કરવામાં આવે છે કારણ કે રહસ્યો, માર્ગો અને અન્ય સુરક્ષા-સંવેદનશીલ વસ્તુઓ ત્યાં સંગ્રહિત કરવામાં આવશે.

અમારા ઉદાહરણમાં, અમે GitHub પર એક નવી સાર્વજનિક રિપોઝીટરી બનાવીશું. તમે તેને ગમે તે કહી શકો છો, અમે બ્લોગપોસ્ટ નામનો ઉપયોગ કરીએ છીએ.

જો YAML ઑબ્જેક્ટ ફાઇલો સ્થાનિક રીતે અથવા ગિટમાં સંગ્રહિત ન હોય, તો તમારે oc અથવા kubectl દ્વિસંગીનો ઉપયોગ કરવો પડશે. નીચેના સ્ક્રીનશોટમાં અમે અમારા નેમસ્પેસ, જમાવટ, સેવા અને રૂટ માટે YAML ને વિનંતી કરી રહ્યા છીએ. આ પહેલા, અમે નવા બનાવેલ રીપોઝીટરી અને સીડીનું ક્લોન કર્યું હતું.

oc get namespace simple-app -o yaml --export > namespace.yaml
oc get deployment httpd -o yaml -n simple-app --export > deployment.yaml
oc get service httpd -o yaml -n simple-app --export > service.yaml
oc get route httpd -o yaml -n simple-app --export > route.yaml

હવે ચાલો deployment.yaml ફાઇલમાં ફેરફાર કરીએ તે ક્ષેત્રને દૂર કરવા માટે કે જે Argo CD સિંક કરી શકતું નથી.

sed -i '/sgeneration: .*/d' deployment.yaml

વધુમાં, રૂટ બદલવાની જરૂર છે. અમે પહેલા મલ્ટિલાઈન વેરીએબલ સેટ કરીશું અને પછી ingress: null ને તે વેરીએબલની સામગ્રી સાથે બદલીશું.

export ROUTE="  ingress:                                                            
    - conditions:
        - status: 'True'
          type: Admitted"

sed -i "s/  ingress: null/$ROUTE/g" route.yaml

તેથી, અમે ફાઇલોને સૉર્ટ કરી છે, જે બાકી છે તે તેમને ગિટ રિપોઝીટરીમાં સાચવવાનું છે. જે પછી આ ભંડાર માહિતીનો એકમાત્ર સ્ત્રોત બની જાય છે, અને ઑબ્જેક્ટ્સમાં કોઈપણ મેન્યુઅલ ફેરફારો સખત પ્રતિબંધિત હોવા જોઈએ.

git commit -am ‘initial commit of objects’
git push origin master

આગળ અમે એ હકીકતથી આગળ વધીએ છીએ કે તમે પહેલાથી જ ArgoCD ને જમાવ્યું છે (આ કેવી રીતે કરવું - પહેલાનું જુઓ પોસ્ટ). તેથી, અમે આર્ગો સીડીમાં અમે બનાવેલ રિપોઝીટરી ઉમેરીશું, જેમાં અમારા ઉદાહરણમાંથી એપ્લિકેશન કોડ છે. ફક્ત ખાતરી કરો કે તમે ચોક્કસ રીપોઝીટરીનો ઉલ્લેખ કર્યો છે કે જે તમે પહેલા બનાવેલ છે.

argocd repo add https://github.com/cooktheryan/blogpost

હવે એપ્લીકેશન બનાવીએ. એપ્લિકેશન મૂલ્યો સેટ કરે છે જેથી GitOps ટૂલકીટ સમજી શકે કે કઈ રીપોઝીટરી અને પાથનો ઉપયોગ કરવો, ઑબ્જેક્ટ્સનું સંચાલન કરવા માટે કઈ OpenShift જરૂરી છે, રીપોઝીટરીની કઈ ચોક્કસ શાખાની જરૂર છે અને શું સંસાધનોને સ્વતઃ-સમન્વયિત કરવું જોઈએ.

argocd app create --project default 
--name simple-app --repo https://github.com/cooktheryan/blogpost.git 
--path . --dest-server https://kubernetes.default.svc 
--dest-namespace simple-app --revision master --sync-policy none

એકવાર આર્ગો સીડીમાં એપ્લિકેશનનો ઉલ્લેખ થઈ જાય, ટૂલકીટ રીપોઝીટરીમાં વ્યાખ્યાઓ સામે પહેલાથી જ જમાવવામાં આવેલ વસ્તુઓને તપાસવાનું શરૂ કરે છે. અમારા ઉદાહરણમાં, ઑટો-સિંક અને ક્લિનઅપ અક્ષમ છે, તેથી ઘટકો હજી બદલાતા નથી. મહેરબાની કરીને નોંધ કરો કે Argo CD ઈન્ટરફેસમાં અમારી એપ્લીકેશનની સ્થિતિ "આઉટ ઓફ સિંક" હશે કારણ કે ArgoCD પ્રદાન કરતું કોઈ લેબલ નથી.
આ જ કારણ છે કે જ્યારે આપણે થોડા સમય પછી સિંક્રનાઇઝેશન શરૂ કરીએ છીએ, ત્યારે ઑબ્જેક્ટ ફરીથી ગોઠવવામાં આવશે નહીં.

હવે અમારી ફાઈલોમાં કોઈ ભૂલો નથી તેની ખાતરી કરવા માટે એક ટેસ્ટ રન કરીએ.

argocd app sync simple-app --dry-run

જો ત્યાં કોઈ ભૂલો નથી, તો પછી તમે સિંક્રનાઇઝેશન પર આગળ વધી શકો છો.

argocd app sync simple-app

અમારી એપ્લિકેશન પર argocd get આદેશ ચલાવ્યા પછી, આપણે જોવું જોઈએ કે એપ્લિકેશનની સ્થિતિ સ્વસ્થ અથવા સમન્વયિત થઈ ગઈ છે. આનો અર્થ એ થશે કે Git રિપોઝીટરીમાંના તમામ સંસાધનો હવે તે સંસાધનોને અનુરૂપ છે જે પહેલાથી જ જમાવવામાં આવ્યા છે.

argocd app get simple-app
Name:               simple-app
Project:            default
Server:             https://kubernetes.default.svc
Namespace:          simple-app
URL:                https://argocd-server-route-argocd.apps.example.com/applications/simple-app
Repo:               https://github.com/cooktheryan/blogpost.git
Target:             master
Path:               .
Sync Policy:        <none>
Sync Status:        Synced to master (60e1678)
Health Status:      Healthy
...   

હવે તમે સ્વતઃ-સમન્વયન અને સફાઈને સક્ષમ કરી શકો છો તેની ખાતરી કરવા માટે કે કંઈપણ મેન્યુઅલી બનાવવામાં આવ્યું નથી અને જ્યારે પણ કોઈ ઑબ્જેક્ટ બનાવવામાં આવે છે અથવા રીપોઝીટરીમાં અપડેટ કરવામાં આવે છે, ત્યારે જમાવટ થશે.

argocd app set simple-app --sync-policy automated --auto-prune

તેથી, અમે સફળતાપૂર્વક GitOps નિયંત્રણ હેઠળ એક એપ્લિકેશન લાવ્યા છીએ જે શરૂઆતમાં GitOpsનો કોઈપણ રીતે ઉપયોગ કરતી ન હતી.

સોર્સ: www.habr.com