ఈ రోజు మనం GitOps యొక్క సూత్రాలు మరియు నమూనాల గురించి మాట్లాడుతాము, అలాగే ఈ నమూనాలు OpenShift ప్లాట్‌ఫారమ్‌లో ఎలా అమలు చేయబడతాయో అలాగే. ఈ అంశంపై ఇంటరాక్టివ్ గైడ్ అందుబాటులో ఉంది .
క్లుప్తంగా, GitOps అనేది ఇన్‌ఫ్రాస్ట్రక్చర్ మరియు అప్లికేషన్ కాన్ఫిగరేషన్‌లను నిర్వహించడానికి Git పుల్ అభ్యర్థనలను ఉపయోగించడం కోసం సాధనల సమితి. GitOpsలోని Git రిపోజిటరీ సిస్టమ్ స్థితి గురించిన సమాచారం యొక్క ఒకే మూలంగా పరిగణించబడుతుంది మరియు ఈ స్థితిలో ఏవైనా మార్పులు ఉంటే పూర్తిగా గుర్తించదగినవి మరియు ఆడిట్ చేయదగినవి.
GitOpsలో మార్పు ట్రాకింగ్ ఆలోచన కొత్తది కాదు; అప్లికేషన్ సోర్స్ కోడ్‌తో పనిచేసేటప్పుడు ఈ విధానం దాదాపు విశ్వవ్యాప్తంగా ఉపయోగించబడింది. GitOps అవస్థాపన మరియు అప్లికేషన్ కాన్ఫిగరేషన్ నిర్వహణలో సారూప్య లక్షణాలను (సమీక్షలు, పుల్ అభ్యర్థనలు, ట్యాగ్‌లు మొదలైనవి) అమలు చేస్తుంది మరియు సోర్స్ కోడ్ నిర్వహణ విషయంలో లాగానే ప్రయోజనాలను అందిస్తుంది.
GitOps కోసం విద్యాపరమైన నిర్వచనం లేదా ఆమోదించబడిన నియమాల సెట్ లేదు, ఈ అభ్యాసం రూపొందించబడిన సూత్రాల సమితి మాత్రమే:
- సిస్టమ్ యొక్క డిక్లరేటివ్ వివరణ Git రిపోజిటరీలో నిల్వ చేయబడుతుంది (configs, పర్యవేక్షణ, మొదలైనవి).
- పుల్ అభ్యర్థనల ద్వారా రాష్ట్ర మార్పులు చేయబడతాయి.
- Git పుష్ అభ్యర్థనలను ఉపయోగించి రిపోజిటరీలోని డేటాకు అనుగుణంగా నడుస్తున్న సిస్టమ్‌ల స్థితిని తీసుకురాబడుతుంది.
GitOps సూత్రాలు
- సిస్టమ్ నిర్వచనాలు సోర్స్ కోడ్‌గా వివరించబడ్డాయి
సిస్టమ్స్ కాన్ఫిగరేషన్ కోడ్‌గా పరిగణించబడుతుంది కాబట్టి ఇది Git రిపోజిటరీలో నిల్వ చేయబడుతుంది మరియు స్వయంచాలకంగా సంస్కరణ చేయబడుతుంది, ఇది సత్యం యొక్క ఒకే మూలంగా పనిచేస్తుంది. ఈ విధానం సిస్టమ్‌లలో రోల్ అవుట్ మరియు రోల్‌బ్యాక్ మార్పులను సులభతరం చేస్తుంది.
- సిస్టమ్‌ల యొక్క కావలసిన స్థితి మరియు కాన్ఫిగరేషన్ Gitలో సెట్ చేయబడతాయి మరియు వెర్షన్ చేయబడతాయి
Gitలో సిస్టమ్‌ల యొక్క కావలసిన స్థితిని నిల్వ చేయడం మరియు సంస్కరణ చేయడం ద్వారా, మేము సిస్టమ్‌లు మరియు అప్లికేషన్‌లకు మార్పులను సులభంగా రోల్ అవుట్ చేయగలము మరియు రోల్ బ్యాక్ చేయగలము. మేము కోడ్ యాజమాన్యాన్ని నియంత్రించడానికి మరియు దాని ప్రామాణికతను ధృవీకరించడానికి Git యొక్క భద్రతా విధానాలను కూడా ఉపయోగించవచ్చు.
- పుల్ అభ్యర్థనల ద్వారా కాన్ఫిగరేషన్ మార్పులు స్వయంచాలకంగా వర్తించబడతాయి
Git పుల్ అభ్యర్థనలను ఉపయోగించి, రిపోజిటరీలోని కాన్ఫిగరేషన్‌లకు మార్పులు ఎలా వర్తింపజేయబడతాయో మనం సులభంగా నియంత్రించవచ్చు. ఉదాహరణకు, వాటిని సమీక్ష కోసం ఇతర బృంద సభ్యులకు అందించవచ్చు లేదా CI పరీక్షలు మొదలైన వాటి ద్వారా అమలు చేయవచ్చు.
మరియు అదే సమయంలో, నిర్వాహక అధికారాలను ఎడమ మరియు కుడికి పంపిణీ చేయవలసిన అవసరం లేదు. కాన్ఫిగరేషన్ మార్పులను చేయడానికి, వినియోగదారులకు ఆ కాన్ఫిగరేషన్‌లు నిల్వ చేయబడిన Git రిపోజిటరీలో తగిన అనుమతులు మాత్రమే అవసరం.
- కాన్ఫిగరేషన్ల అనియంత్రిత డ్రిఫ్ట్ సమస్యను పరిష్కరించడం
సిస్టమ్ యొక్క కావలసిన స్థితి Git రిపోజిటరీలో నిల్వ చేయబడిన తర్వాత, మనం చేయాల్సిందల్లా సిస్టమ్ యొక్క ప్రస్తుత స్థితి దాని కావలసిన స్థితికి సరిపోలుతుందని నిర్ధారించే సాఫ్ట్‌వేర్‌ను కనుగొనడమే. ఇది కాకపోతే, ఈ సాఫ్ట్‌వేర్ - సెట్టింగ్‌లను బట్టి - దాని స్వంత వ్యత్యాసాన్ని తొలగించాలి లేదా కాన్ఫిగరేషన్ డ్రిఫ్ట్ గురించి మాకు తెలియజేయాలి.
OpenShift కోసం GitOps మోడల్స్
ఆన్-క్లస్టర్ రిసోర్స్ రీకన్సిలర్
ఈ మోడల్ ప్రకారం, క్లస్టర్‌కి ఒక కంట్రోలర్ ఉంది, ఇది Git రిపోజిటరీలోని కుబెర్నెట్స్ వనరులను (YAML ఫైల్స్) క్లస్టర్ యొక్క నిజమైన వనరులతో పోల్చడానికి బాధ్యత వహిస్తుంది. వ్యత్యాసాలు గుర్తించబడితే, కంట్రోలర్ నోటిఫికేషన్‌లను పంపుతుంది మరియు వ్యత్యాసాలను సరిచేయడానికి బహుశా చర్య తీసుకుంటుంది. ఈ GitOps మోడల్ Anthos కాన్ఫిగ్ మేనేజ్‌మెంట్ మరియు వీవ్‌వర్క్స్ ఫ్లక్స్‌లో ఉపయోగించబడుతుంది.
ఎక్స్‌టర్నల్ రిసోర్స్ రీకన్సిలర్ (పుష్)
“Git repository - Kubernetes cluster” జతలలో వనరులను సమకాలీకరించడానికి మేము ఒకటి లేదా అంతకంటే ఎక్కువ కంట్రోలర్‌లను కలిగి ఉన్నప్పుడు, ఈ మోడల్ మునుపటి దాని యొక్క వైవిధ్యంగా పరిగణించబడుతుంది. ఇక్కడ ఉన్న వ్యత్యాసం ఏమిటంటే, నిర్వహించబడే ప్రతి క్లస్టర్‌కు దాని స్వంత ప్రత్యేక నియంత్రిక అవసరం లేదు. Git - k8s క్లస్టర్ జతలు తరచుగా CRDలు (కస్టమ్ రిసోర్స్ డెఫినిషన్‌లు)గా నిర్వచించబడతాయి, ఇది కంట్రోలర్ సమకాలీకరణను ఎలా నిర్వహించాలో వివరిస్తుంది. ఈ మోడల్‌లో, కంట్రోలర్‌లు CRDలో పేర్కొన్న Git రిపోజిటరీని CRDలో కూడా పేర్కొనబడిన కుబెర్నెట్స్ క్లస్టర్ వనరులతో సరిపోల్చుతాయి మరియు పోలిక ఫలితాల ఆధారంగా తగిన చర్యలను నిర్వహిస్తాయి. ముఖ్యంగా, ఈ GitOps మోడల్ ArgoCDలో ఉపయోగించబడుతుంది.
OpenShift ప్లాట్‌ఫారమ్‌లో GitOps
బహుళ-క్లస్టర్ కుబెర్నెట్స్ మౌలిక సదుపాయాల నిర్వహణ
కుబెర్నెటెస్ వ్యాప్తి మరియు బహుళ-క్లౌడ్ వ్యూహాలు మరియు ఎడ్జ్ కంప్యూటింగ్‌కు పెరుగుతున్న ప్రజాదరణతో, ఒక్కో కస్టమర్‌కు సగటున ఓపెన్‌షిఫ్ట్ క్లస్టర్‌ల సంఖ్య కూడా పెరుగుతోంది.
ఉదాహరణకు, ఎడ్జ్ కంప్యూటింగ్‌ని ఉపయోగిస్తున్నప్పుడు, ఒక కస్టమర్ క్లస్టర్లు వందలు లేదా వేలల్లో కూడా అమర్చబడతాయి. ఫలితంగా, అతను పబ్లిక్ క్లౌడ్ మరియు ఆన్-ప్రిమైజ్‌లో అనేక స్వతంత్ర లేదా సమన్వయ ఓపెన్‌షిఫ్ట్ క్లస్టర్‌లను నిర్వహించవలసి వస్తుంది.
ఈ సందర్భంలో, చాలా సమస్యలను పరిష్కరించాలి, ముఖ్యంగా:
- క్లస్టర్లు ఒకే స్థితిలో ఉన్నాయని నియంత్రించండి (కాన్ఫిగరేషన్‌లు, పర్యవేక్షణ, నిల్వ మొదలైనవి)
- తెలిసిన స్థితి ఆధారంగా క్లస్టర్‌లను పునఃసృష్టించండి (లేదా పునరుద్ధరించండి).
- తెలిసిన స్థితి ఆధారంగా కొత్త క్లస్టర్‌లను సృష్టించండి.
- బహుళ OpenShift క్లస్టర్‌లకు మార్పులను రోల్ అవుట్ చేయండి.
- బహుళ OpenShift క్లస్టర్‌లలో మార్పులను వెనక్కి తీసుకోండి.
- టెంప్లేట్ చేసిన కాన్ఫిగరేషన్‌లను విభిన్న వాతావరణాలకు లింక్ చేయండి.
అప్లికేషన్ కాన్ఫిగరేషన్‌లు
వారి జీవితచక్రం సమయంలో, అప్లికేషన్‌లు ఉత్పత్తి క్లస్టర్‌లో ముగిసే ముందు తరచుగా క్లస్టర్‌ల గొలుసు (దేవ్, స్టేజ్, మొదలైనవి) గుండా వెళతాయి. అదనంగా, లభ్యత మరియు స్కేలబిలిటీ అవసరాల కారణంగా, కస్టమర్‌లు తరచుగా అప్లికేషన్‌లను బహుళ ఆన్-ప్రాంగణ క్లస్టర్లు లేదా పబ్లిక్ క్లౌడ్ ప్లాట్‌ఫారమ్‌లోని బహుళ ప్రాంతాలలో అమలు చేస్తారు.
ఈ సందర్భంలో, కింది పనులు పరిష్కరించబడాలి:
- క్లస్టర్‌ల (దేవ్, స్టేజ్, మొదలైనవి) మధ్య అప్లికేషన్‌ల కదలికను (బైనరీలు, కాన్ఫిగర్‌లు మొదలైనవి) నిర్ధారించుకోండి.
- అనేక OpenShift క్లస్టర్‌లలో అప్లికేషన్‌లకు (బైనరీలు, కాన్ఫిగర్‌లు మొదలైనవి) మార్పులను రోల్ అవుట్ చేయండి.
- మునుపటి తెలిసిన స్థితికి అనువర్తనాలకు చేసిన మార్పులను రోల్ బ్యాక్ చేయండి.
OpenShift GitOps కేసులను ఉపయోగించండి
1. Git రిపోజిటరీ నుండి మార్పులను వర్తింపజేయడం
క్లస్టర్ అడ్మినిస్ట్రేటర్ OpenShift క్లస్టర్ కాన్ఫిగరేషన్‌లను Git రిపోజిటరీలో నిల్వ చేయవచ్చు మరియు కొత్త క్లస్టర్‌లను సులభంగా సృష్టించడానికి మరియు వాటిని Git రిపోజిటరీలో నిల్వ చేయబడిన స్థితికి సమానమైన స్థితికి తీసుకురావడానికి స్వయంచాలకంగా వాటిని వర్తింపజేయవచ్చు.
2. సీక్రెట్ మేనేజర్‌తో సమకాలీకరణ
దీని కోసం ప్రత్యేకంగా రూపొందించిన సాధనాలను ఉపయోగించి వాటిని నిర్వహించడానికి వాల్ట్ వంటి తగిన సాఫ్ట్‌వేర్‌తో OpenShift రహస్య వస్తువులను సమకాలీకరించగల సామర్థ్యం నుండి నిర్వాహకుడు కూడా ప్రయోజనం పొందుతారు.
3. డ్రిఫ్ట్ కాన్ఫిగరేషన్ల నియంత్రణ
నిజమైన కాన్ఫిగరేషన్‌లు మరియు రిపోజిటరీలో పేర్కొన్న వాటి మధ్య వ్యత్యాసాలను OpenShift GitOps స్వయంగా గుర్తించి, హెచ్చరిస్తే మాత్రమే అడ్మిన్ అనుకూలంగా ఉంటారు, తద్వారా వారు డ్రిఫ్ట్‌కు త్వరగా ప్రతిస్పందించగలరు.
4. కాన్ఫిగరేషన్ డ్రిఫ్ట్ గురించి నోటిఫికేషన్‌లు
అడ్మినిస్ట్రేటర్ తన స్వంతంగా తగిన చర్యలు తీసుకోవడానికి కాన్ఫిగరేషన్ డ్రిఫ్ట్ కేసుల గురించి త్వరగా తెలుసుకోవాలనుకున్నప్పుడు అవి ఉపయోగకరంగా ఉంటాయి.
5. డ్రిఫ్టింగ్ చేసినప్పుడు కాన్ఫిగరేషన్ల మాన్యువల్ సింక్రొనైజేషన్
కాన్ఫిగరేషన్ డ్రిఫ్ట్ సందర్భంలో ఓపెన్‌షిఫ్ట్ క్లస్టర్‌ను Git రిపోజిటరీతో సమకాలీకరించడానికి, క్లస్టర్‌ను త్వరగా మునుపటి స్థితికి తిరిగి తీసుకురావడానికి నిర్వాహకుడిని అనుమతిస్తుంది.
6.డ్రిఫ్టింగ్ చేసేటప్పుడు కాన్ఫిగరేషన్ల యొక్క ఆటో-సింక్రొనైజేషన్
డ్రిఫ్ట్ కనుగొనబడినప్పుడు స్వయంచాలకంగా రిపోజిటరీతో సమకాలీకరించడానికి అడ్మినిస్ట్రేటర్ OpenShift క్లస్టర్‌ను కాన్ఫిగర్ చేయవచ్చు, తద్వారా క్లస్టర్ కాన్ఫిగరేషన్ ఎల్లప్పుడూ Gitలోని కాన్ఫిగరేషన్‌లతో సరిపోలుతుంది.
7. అనేక క్లస్టర్లు - ఒక రిపోజిటరీ
అడ్మినిస్ట్రేటర్ ఒక Git రిపోజిటరీలో అనేక విభిన్న OpenShift క్లస్టర్‌ల కాన్ఫిగరేషన్‌లను నిల్వ చేయవచ్చు మరియు అవసరమైన విధంగా వాటిని ఎంపిక చేసుకోవచ్చు.
8. క్లస్టర్ కాన్ఫిగరేషన్ల సోపానక్రమం (వారసత్వం)
అడ్మిన్ రిపోజిటరీలో క్లస్టర్ కాన్ఫిగరేషన్ల సోపానక్రమాన్ని సెట్ చేయవచ్చు (స్టేజ్, ప్రోడ్, యాప్ పోర్ట్‌ఫోలియో మొదలైనవి వారసత్వంతో). మరో మాటలో చెప్పాలంటే, ఒకటి లేదా అంతకంటే ఎక్కువ క్లస్టర్‌లకు కాన్ఫిగరేషన్‌లు వర్తింపజేయాలా వద్దా అని ఇది నిర్ణయించగలదు.
ఉదాహరణకు, ఒక నిర్వాహకుడు Git రిపోజిటరీలో “ప్రొడక్షన్ క్లస్టర్లు (ప్రొడ్) → సిస్టమ్ X క్లస్టర్లు → ప్రొడక్షన్ క్లస్టర్‌ల సిస్టమ్ X”ని సెట్ చేస్తే, సిస్టమ్ X యొక్క ప్రొడక్షన్ క్లస్టర్‌లకు కింది కాన్ఫిగరేషన్ల కలయిక వర్తించబడుతుంది:
- అన్ని ఉత్పత్తి క్లస్టర్‌లకు సాధారణ కాన్ఫిగరేషన్‌లు.
- సిస్టమ్ X క్లస్టర్ కోసం కాన్ఫిగరేషన్‌లు.
- X సిస్టమ్ ప్రొడక్షన్ క్లస్టర్ కోసం కాన్ఫిగరేషన్‌లు.
9. టెంప్లేట్‌లు మరియు కాన్ఫిగరేషన్ ఓవర్‌రైడ్‌లు
అడ్మినిస్ట్రేటర్ వారసత్వంగా వచ్చిన కాన్ఫిగర్‌ల సమితిని మరియు వాటి విలువలను భర్తీ చేయవచ్చు, ఉదాహరణకు, అవి వర్తించే నిర్దిష్ట క్లస్టర్‌ల కోసం కాన్ఫిగరేషన్‌ను చక్కగా ట్యూన్ చేయడానికి.
10. కాన్ఫిగరేషన్‌లు, అప్లికేషన్ కాన్ఫిగరేషన్ల కోసం సెలెక్టివ్ చేర్చడం మరియు మినహాయించడం
నిర్వాహకుడు నిర్దిష్ట లక్షణాలతో క్లస్టర్‌లకు నిర్దిష్ట కాన్ఫిగరేషన్ల అప్లికేషన్ లేదా నాన్-అప్లికేషన్ కోసం షరతులను సెట్ చేయవచ్చు.
11. టెంప్లేట్ మద్దతు
డెవలపర్లు ప్రతి నిర్దిష్ట అప్లికేషన్ కోసం అత్యంత సముచితమైన ఆకృతిని ఉపయోగించడానికి అప్లికేషన్ వనరులు ఎలా నిర్వచించబడతాయో (హెల్మ్ చార్ట్, ప్యూర్ కుబెర్నెట్స్ యామల్, మొదలైనవి) ఎంచుకునే సామర్థ్యం నుండి ప్రయోజనం పొందుతారు.
OpenShift ప్లాట్‌ఫారమ్‌లో GitOps సాధనాలు
ఆర్గోసిడి
ArgoCD ఎక్స్‌టర్నల్ రిసోర్స్ రీకన్సిల్ మోడల్‌ను అమలు చేస్తుంది మరియు క్లస్టర్లు మరియు Git రిపోజిటరీల మధ్య అనేక సంబంధాలను ఆర్కెస్ట్రేట్ చేయడానికి కేంద్రీకృత 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}')ArgoCD సర్వర్‌ని మెరుగుపరచడం, తద్వారా దీనిని OpenShift రూట్ ద్వారా చూడవచ్చు
# 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=RedirectArgoCD 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/argocdArgoCD సర్వర్ అడ్మిన్ పాస్‌వర్డ్‌ను మార్చడం
# 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 సర్వర్‌తో పని చేయవచ్చు.
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 రిపోజిటరీని సృష్టించండి.
- మేము మా ప్రస్తుత వస్తువులను ఎగుమతి చేస్తాము మరియు వాటిని Git రిపోజిటరీకి అప్‌లోడ్ చేస్తాము.
- GitOps సాధనాలను ఎంచుకోవడం మరియు అమలు చేయడం.
- మేము ఈ టూల్‌కిట్‌కు మా రిపోజిటరీని జోడిస్తాము.
- మేము మా GitOps టూల్‌కిట్‌లో అప్లికేషన్‌ను నిర్వచించాము.
- మేము GitOps టూల్‌కిట్‌ని ఉపయోగించి అప్లికేషన్ యొక్క టెస్ట్ రన్ చేస్తాము.
- మేము GitOps టూల్‌కిట్‌ని ఉపయోగించి ఆబ్జెక్ట్‌లను సింక్రొనైజ్ చేస్తాము.
- వస్తువుల కత్తిరింపు మరియు స్వీయ-సమకాలీకరణను ప్రారంభించండి.
గతంలో పేర్కొన్న విధంగా , GitOpsలో Kubernetes క్లస్టర్(లు)లోని అన్ని వస్తువుల గురించిన సమాచారం యొక్క ఒకే ఒక మూలం ఉంది - Git రిపోజిటరీ. తరువాత, మేము మీ సంస్థ ఇప్పటికే Git రిపోజిటరీని ఉపయోగిస్తుందనే ఆవరణ నుండి కొనసాగుతాము. ఇది పబ్లిక్ లేదా ప్రైవేట్ కావచ్చు, కానీ ఇది తప్పనిసరిగా కుబెర్నెట్స్ క్లస్టర్‌లకు అందుబాటులో ఉండాలి. ఇది అప్లికేషన్ కోడ్ కోసం అదే రిపోజిటరీ కావచ్చు లేదా డిప్లాయ్‌మెంట్‌ల కోసం ప్రత్యేకంగా సృష్టించబడిన ప్రత్యేక రిపోజిటరీ కావచ్చు. రహస్యాలు, మార్గాలు మరియు ఇతర భద్రతా-సెన్సిటివ్ విషయాలు నిల్వ చేయబడతాయి కాబట్టి రిపోజిటరీలో ఖచ్చితమైన అనుమతులు కలిగి ఉండాలని సిఫార్సు చేయబడింది.
మా ఉదాహరణలో, మేము GitHubలో కొత్త పబ్లిక్ రిపోజిటరీని సృష్టిస్తాము. మీకు నచ్చిన దాన్ని మీరు కాల్ చేయవచ్చు, మేము బ్లాగ్‌పోస్ట్ అనే పేరును ఉపయోగిస్తాము.
YAML ఆబ్జెక్ట్ ఫైల్‌లు స్థానికంగా లేదా Gitలో నిల్వ చేయబడకపోతే, మీరు oc లేదా kubectl బైనరీలను ఉపయోగించాల్సి ఉంటుంది. దిగువ స్క్రీన్‌షాట్‌లో మేము మా నేమ్‌స్పేస్, విస్తరణ, సేవ మరియు మార్గం కోసం YAMLని అభ్యర్థిస్తున్నాము. దీనికి ముందు, మేము కొత్తగా సృష్టించిన రిపోజిటరీ మరియు cdని క్లోన్ చేసాము.
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ఇప్పుడు Argo CD సమకాలీకరించలేని ఫీల్డ్‌ను తీసివేయడానికి deployment.yaml ఫైల్‌ని ఎడిట్ చేద్దాం.
sed -i '/sgeneration: .*/d' deployment.yamlదీంతోపాటు రూట్ మార్చాల్సి ఉంది. మేము మొదట మల్టీలైన్ వేరియబుల్‌ని సెట్ చేసి, ఆపై ప్రవేశాన్ని భర్తీ చేస్తాము: ఆ వేరియబుల్ యొక్క కంటెంట్‌లతో శూన్యం.
export ROUTE=" ingress:
- conditions:
- status: 'True'
type: Admitted"
sed -i "s/ ingress: null/$ROUTE/g" route.yamlకాబట్టి, మేము ఫైల్‌లను క్రమబద్ధీకరించాము, వాటిని Git రిపోజిటరీలో సేవ్ చేయడం మాత్రమే మిగిలి ఉంది. దీని తర్వాత ఈ రిపోజిటరీ మాత్రమే సమాచార వనరుగా మారుతుంది మరియు వస్తువులకు ఏవైనా మాన్యువల్ మార్పులు ఖచ్చితంగా నిషేధించబడాలి.
git commit -am ‘initial commit of objects’
git push origin masterమీరు ఇప్పటికే ArgoCDని అమలు చేశారనే వాస్తవం నుండి మేము ముందుకు వెళ్తాము (దీన్ని ఎలా చేయాలో - మునుపటిది చూడండి ) కాబట్టి, మేము సృష్టించిన రిపోజిటరీని Argo CDకి జోడిస్తాము, మా ఉదాహరణ నుండి అప్లికేషన్ కోడ్ ఉంటుంది. మీరు ఇంతకు ముందు సృష్టించిన ఖచ్చితమైన రిపోజిటరీని పేర్కొన్నారని నిర్ధారించుకోండి.
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
అర్గో CDలో అప్లికేషన్ పేర్కొనబడిన తర్వాత, టూల్‌కిట్ రిపోజిటరీలోని నిర్వచనాలకు వ్యతిరేకంగా ఇప్పటికే అమలు చేయబడిన వస్తువులను తనిఖీ చేయడం ప్రారంభిస్తుంది. మా ఉదాహరణలో, స్వీయ-సమకాలీకరణ మరియు శుభ్రపరచడం నిలిపివేయబడ్డాయి, కాబట్టి మూలకాలు ఇంకా మారవు. ArgoCD అందించే లేబుల్ లేనందున Argo CD ఇంటర్‌ఫేస్‌లో మా అప్లికేషన్ "సమకాలీకరించబడలేదు" అనే స్థితిని కలిగి ఉంటుందని దయచేసి గమనించండి.
అందుకే మనం కొంచెం ఆలస్యంగా సమకాలీకరణను ప్రారంభించినప్పుడు, వస్తువులు మళ్లీ అమర్చబడవు.
ఇప్పుడు మన ఫైల్‌లలో లోపాలు లేవని నిర్ధారించుకోవడానికి టెస్ట్ రన్ చేద్దాం.
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