പ്ലഗിന്നുകൾ, എസ്എംഎസ് അല്ലെങ്കിൽ രജിസ്ട്രേഷൻ ഇല്ലാതെ ഞങ്ങൾ GKE-യിൽ ഒരു വിന്യാസ ടാസ്ക് സൃഷ്ടിക്കുന്നു. നമുക്ക് ജെങ്കിൻസിന്റെ ജാക്കറ്റിനടിയിൽ ഒന്നു നോക്കാം

ഞങ്ങളുടെ ഡവലപ്‌മെന്റ് ടീമുകളിലൊന്നിന്റെ ടീം ലീഡ് അവരുടെ പുതിയ ആപ്ലിക്കേഷൻ പരീക്ഷിക്കാൻ ഞങ്ങളോട് ആവശ്യപ്പെട്ടതോടെയാണ് ഇതെല്ലാം ആരംഭിച്ചത്, അത് തലേദിവസം കണ്ടെയ്‌നറൈസ് ചെയ്തു. ഞാനത് പോസ്റ്റ് ചെയ്തു. ഏകദേശം 20 മിനിറ്റിനുശേഷം, ആപ്ലിക്കേഷൻ അപ്‌ഡേറ്റ് ചെയ്യാനുള്ള അഭ്യർത്ഥന ലഭിച്ചു, കാരണം വളരെ അത്യാവശ്യമായ ഒരു കാര്യം അവിടെ ചേർത്തിട്ടുണ്ട്. ഞാൻ പുതുക്കി. ഒരു രണ്ടു മണിക്കൂർ കൂടി കഴിഞ്ഞാൽ... അടുത്തതായി എന്താണ് സംഭവിക്കാൻ തുടങ്ങിയതെന്ന് നിങ്ങൾക്ക് ഊഹിക്കാം...

ഞാൻ സമ്മതിക്കണം, ഞാൻ തികച്ചും മടിയനാണ് (ഞാൻ ഇത് നേരത്തെ സമ്മതിച്ചില്ലേ? ഇല്ലേ?), കൂടാതെ ടീം ലീഡുകൾക്ക് ജെങ്കിൻസിലേക്ക് പ്രവേശനമുണ്ട്, അതിൽ ഞങ്ങൾക്ക് എല്ലാ CI/CD ഉണ്ട്, ഞാൻ ചിന്തിച്ചു: അവനെ വിന്യസിക്കട്ടെ അവൻ ആഗ്രഹിക്കുന്നത്രയും! ഞാൻ ഒരു തമാശ ഓർത്തു: ഒരു മനുഷ്യന് ഒരു മീൻ കൊടുക്കുക, അവൻ ഒരു ദിവസം തിന്നും; ഒരു വ്യക്തിയെ ഫെഡ് എന്ന് വിളിക്കുക, അയാൾക്ക് ജീവിതകാലം മുഴുവൻ ഭക്ഷണം നൽകും. ഒപ്പം പോയി ജോലിയിൽ തന്ത്രങ്ങൾ കളിക്കുക, വിജയകരമായി നിർമ്മിച്ച ഏതെങ്കിലും പതിപ്പിന്റെ ആപ്ലിക്കേഷൻ അടങ്ങുന്ന ഒരു കണ്ടെയ്നർ കുബറിലേക്ക് വിന്യസിക്കാനും അതിലേക്ക് ഏതെങ്കിലും മൂല്യങ്ങൾ കൈമാറാനും കഴിയും ENV (എന്റെ മുത്തച്ഛൻ, ഒരു ഭാഷാശാസ്ത്രജ്ഞൻ, പണ്ട് ഇംഗ്ലീഷ് അധ്യാപകൻ, ഇപ്പോൾ ഈ വാചകം വായിച്ചതിനുശേഷം അവന്റെ ക്ഷേത്രത്തിലേക്ക് വിരൽ ചുഴറ്റി എന്നെ വളരെ പ്രകടമായി നോക്കും).

അതിനാൽ, ഞാൻ എങ്ങനെ പഠിച്ചുവെന്ന് ഈ കുറിപ്പിൽ ഞാൻ നിങ്ങളോട് പറയും:

1. ജോലിയിൽ നിന്നോ മറ്റ് ജോലികളിൽ നിന്നോ ജെങ്കിൻസിലെ ജോലികൾ ചലനാത്മകമായി അപ്ഡേറ്റ് ചെയ്യുക;
2. ജെങ്കിൻസ് ഏജന്റ് ഇൻസ്റ്റാൾ ചെയ്ത ഒരു നോഡിൽ നിന്ന് ക്ലൗഡ് കൺസോളിലേക്ക് (ക്ലൗഡ് ഷെൽ) ബന്ധിപ്പിക്കുക;
3. Google Kubernetes എഞ്ചിനിലേക്ക് വർക്ക് ലോഡ് വിന്യസിക്കുക.

സത്യത്തിൽ, തീർച്ചയായും, ഞാൻ ഒരു പരിധിവരെ വിവേചനരഹിതനാണ്. നിങ്ങൾക്ക് Google ക്ലൗഡിൽ ഇൻഫ്രാസ്ട്രക്ചറിന്റെ ഒരു ഭാഗമെങ്കിലും ഉണ്ടെന്ന് അനുമാനിക്കപ്പെടുന്നു, അതിനാൽ, നിങ്ങൾ അതിന്റെ ഉപയോക്താവാണ്, തീർച്ചയായും നിങ്ങൾക്ക് ഒരു GCP അക്കൗണ്ട് ഉണ്ട്. എന്നാൽ ഈ കുറിപ്പ് അതിനെക്കുറിച്ചല്ല.

ഇതാണ് എന്റെ അടുത്ത ചീറ്റ് ഷീറ്റ്. അത്തരം കുറിപ്പുകൾ ഒരു കേസിൽ മാത്രം എഴുതാൻ ഞാൻ ആഗ്രഹിക്കുന്നു: എനിക്ക് ഒരു പ്രശ്നം നേരിടേണ്ടി വന്നു, അത് എങ്ങനെ പരിഹരിക്കണമെന്ന് എനിക്ക് ആദ്യം അറിയില്ലായിരുന്നു, പരിഹാരം റെഡിമെയ്ഡ് ഗൂഗിൾ ചെയ്തില്ല, അതിനാൽ ഞാൻ അത് ഭാഗങ്ങളായി ഗൂഗിൾ ചെയ്ത് ഒടുവിൽ പ്രശ്നം പരിഹരിച്ചു. ഭാവിയിൽ, ഞാൻ ഇത് എങ്ങനെ ചെയ്തുവെന്ന് ഞാൻ മറക്കുമ്പോൾ, എനിക്ക് എല്ലാം വീണ്ടും കഷണങ്ങളായി ഗൂഗിൾ ചെയ്ത് ഒരുമിച്ച് കംപൈൽ ചെയ്യേണ്ടതില്ല, അത്തരം ചീറ്റ് ഷീറ്റുകൾ ഞാൻ സ്വയം എഴുതുന്നു.

നിരാകരണം: 1. കുറിപ്പ് എഴുതിയത് "എനിക്കുവേണ്ടി", വേഷത്തിന് മികച്ച പരിശീലനം ബാധകമല്ല. അഭിപ്രായങ്ങളിലെ "ഇത് ഇങ്ങനെ ചെയ്താൽ നന്നായിരുന്നു" എന്ന ഓപ്ഷനുകൾ വായിച്ചതിൽ എനിക്ക് സന്തോഷമുണ്ട്.
2. നോട്ടിന്റെ പ്രയോഗിച്ച ഭാഗം ഉപ്പായി കണക്കാക്കുന്നുവെങ്കിൽ, എന്റെ എല്ലാ മുൻ കുറിപ്പുകളും പോലെ ഇതും ഒരു ദുർബലമായ ഉപ്പ് ലായനിയാണ്.

ജെങ്കിൻസിലെ ജോലി ക്രമീകരണങ്ങൾ ചലനാത്മകമായി അപ്ഡേറ്റ് ചെയ്യുന്നു

നിങ്ങളുടെ ചോദ്യം ഞാൻ മുൻകൂട്ടി കാണുന്നു: ഡൈനാമിക് ജോബ് അപ്‌ഡേറ്റ് ഇതുമായി എന്താണ് ചെയ്യേണ്ടത്? സ്ട്രിംഗ് പാരാമീറ്ററിന്റെ മൂല്യം സ്വമേധയാ നൽകുക, നിങ്ങൾ പോകൂ!

ഞാൻ ഉത്തരം നൽകുന്നു: ഞാൻ ശരിക്കും മടിയനാണ്, അവർ പരാതിപ്പെടുമ്പോൾ എനിക്ക് അത് ഇഷ്ടമല്ല: മിഷ, വിന്യാസം തകരുകയാണ്, എല്ലാം പോയി! നിങ്ങൾ നോക്കാൻ തുടങ്ങുന്നു, ചില ടാസ്‌ക് ലോഞ്ച് പാരാമീറ്ററിന്റെ മൂല്യത്തിൽ അക്ഷരത്തെറ്റുണ്ട്. അതിനാൽ, എല്ലാം കഴിയുന്നത്ര കാര്യക്ഷമമായി ചെയ്യാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. തിരഞ്ഞെടുക്കാനുള്ള മൂല്യങ്ങളുടെ ഒരു ലിസ്റ്റ് നൽകിക്കൊണ്ട് ഉപയോക്താവിനെ നേരിട്ട് ഡാറ്റ നൽകുന്നതിൽ നിന്ന് തടയാൻ കഴിയുമെങ്കിൽ, ഞാൻ തിരഞ്ഞെടുക്കൽ സംഘടിപ്പിക്കുന്നു.

പ്ലാൻ ഇതാണ്: ഞങ്ങൾ ജെൻകിൻസിൽ ഒരു ജോലി സൃഷ്ടിക്കുന്നു, അതിൽ സമാരംഭിക്കുന്നതിന് മുമ്പ്, ഞങ്ങൾക്ക് ലിസ്റ്റിൽ നിന്ന് ഒരു പതിപ്പ് തിരഞ്ഞെടുക്കാം, ഇത് വഴി കണ്ടെയ്നറിലേക്ക് കൈമാറിയ പാരാമീറ്ററുകൾക്കുള്ള മൂല്യങ്ങൾ വ്യക്തമാക്കാം. ENV, പിന്നീട് അത് കണ്ടെയ്നർ ശേഖരിക്കുകയും കണ്ടെയ്നർ രജിസ്ട്രിയിലേക്ക് തള്ളുകയും ചെയ്യുന്നു. തുടർന്ന് അവിടെ നിന്ന് കണ്ടെയ്നർ ക്യൂബറിൽ വിക്ഷേപിക്കുന്നു ജോലിഭാരം ജോലിയിൽ വ്യക്തമാക്കിയ പാരാമീറ്ററുകൾക്കൊപ്പം.

ജെൻകിൻസിൽ ജോലി സൃഷ്ടിക്കുന്നതിനും സജ്ജീകരിക്കുന്നതിനുമുള്ള പ്രക്രിയ ഞങ്ങൾ പരിഗണിക്കില്ല, ഇത് വിഷയത്തിന് പുറത്താണ്. ടാസ്ക് തയ്യാറാണെന്ന് ഞങ്ങൾ അനുമാനിക്കും. പതിപ്പുകൾക്കൊപ്പം അപ്‌ഡേറ്റ് ചെയ്‌ത ലിസ്‌റ്റ് നടപ്പിലാക്കാൻ, ഞങ്ങൾക്ക് രണ്ട് കാര്യങ്ങൾ ആവശ്യമാണ്: പ്രിയോറി സാധുവായ പതിപ്പ് നമ്പറുകളുള്ള നിലവിലുള്ള ഒരു സോഴ്‌സ് ലിസ്റ്റും അതുപോലെയുള്ള ഒരു വേരിയബിളും ചോയ്സ് പാരാമീറ്റർ ചുമതലയിൽ. നമ്മുടെ ഉദാഹരണത്തിൽ, വേരിയബിളിന് പേരിടാം BUILD_VERSION, ഞങ്ങൾ അതിൽ വിശദമായി വസിക്കില്ല. എന്നാൽ സോഴ്സ് ലിസ്റ്റിലേക്ക് നമുക്ക് സൂക്ഷ്മമായി നോക്കാം.

അത്ര അധികം ഓപ്ഷനുകൾ ഇല്ല. രണ്ട് കാര്യങ്ങൾ പെട്ടെന്ന് മനസ്സിൽ വന്നു:

• ജെങ്കിൻസ് അതിന്റെ ഉപയോക്താക്കൾക്ക് നൽകുന്ന റിമോട്ട് ആക്സസ് API ഉപയോഗിക്കുക;
• റിമോട്ട് റിപ്പോസിറ്ററി ഫോൾഡറിന്റെ ഉള്ളടക്കങ്ങൾ അഭ്യർത്ഥിക്കുക (ഞങ്ങളുടെ കാര്യത്തിൽ ഇത് JFrog ആർട്ടിഫാക്‌ടറിയാണ്, അത് പ്രധാനമല്ല).

ജെങ്കിൻസ് റിമോട്ട് ആക്സസ് API

സ്ഥാപിതമായ മികച്ച പാരമ്പര്യമനുസരിച്ച്, ദൈർഘ്യമേറിയ വിശദീകരണങ്ങൾ ഒഴിവാക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.
ആദ്യ ഖണ്ഡികയുടെ ഒരു ഭാഗത്തിന്റെ സ്വതന്ത്ര വിവർത്തനം മാത്രമേ ഞാൻ അനുവദിക്കൂ API ഡോക്യുമെന്റേഷന്റെ ആദ്യ പേജ്:

അതിന്റെ പ്രവർത്തനക്ഷമതയിലേക്കുള്ള വിദൂര മെഷീൻ-റീഡബിൾ ആക്സസിനായി ജെങ്കിൻസ് ഒരു API നൽകുന്നു. <…> റിമോട്ട് ആക്‌സസ് ഒരു REST പോലെയുള്ള ശൈലിയിൽ വാഗ്ദാനം ചെയ്യുന്നു. ഇതിനർത്ഥം എല്ലാ ഫീച്ചറുകളിലേക്കും ഒരൊറ്റ എൻട്രി പോയിന്റ് ഇല്ല, പകരം "" പോലെയുള്ള ഒരു URL.../api/", എവിടെ"പങ്ക് € |"അർത്ഥം API കഴിവുകൾ പ്രയോഗിക്കുന്ന ഒബ്ജക്റ്റ് എന്നാണ്.

മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഞങ്ങൾ ഇപ്പോൾ സംസാരിക്കുന്ന വിന്യാസ ടാസ്‌ക് ലഭ്യമാണെങ്കിൽ http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build, തുടർന്ന് ഈ ടാസ്ക്കിനുള്ള API വിസിലുകൾ ഇവിടെ ലഭ്യമാണ് http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/

അടുത്തതായി, ഏത് രൂപത്തിൽ ഔട്ട്പുട്ട് സ്വീകരിക്കണമെന്ന് നമുക്ക് തിരഞ്ഞെടുക്കാം. ഈ സാഹചര്യത്തിൽ മാത്രമേ API ഫിൽട്ടർ ചെയ്യാൻ അനുവദിക്കൂ എന്നതിനാൽ നമുക്ക് XML-ൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാം.

എല്ലാ ജോലിയുടെയും ഒരു ലിസ്റ്റ് ലഭിക്കാൻ ശ്രമിക്കാം. അസംബ്ലി നാമത്തിൽ മാത്രമേ ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ളൂ (പ്രദർശന നാമം) അതിന്റെ ഫലവും (ഫലം):

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]

ഇത് പ്രവർത്തിച്ചോ?

ഇനി ഫലത്തിൽ അവസാനിക്കുന്ന റണ്ണുകൾ മാത്രം ഫിൽട്ടർ ചെയ്യാം വിജയം. നമുക്ക് വാദം ഉപയോഗിക്കാം &പെടുത്തിയിട്ടില്ല ഒരു പാരാമീറ്റർ എന്ന നിലയിൽ നമ്മൾ അതിനെ തുല്യമല്ലാത്ത ഒരു മൂല്യത്തിലേക്കുള്ള പാതയിലൂടെ കൈമാറും വിജയം. അതെ അതെ. ഇരട്ട നെഗറ്റീവ് ഒരു പ്രസ്താവനയാണ്. ഞങ്ങൾക്ക് താൽപ്പര്യമില്ലാത്ത എല്ലാം ഞങ്ങൾ ഒഴിവാക്കുന്നു:

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!='SUCCESS']

വിജയിച്ചവരുടെ പട്ടികയുടെ സ്ക്രീൻഷോട്ട്

ശരി, വിനോദത്തിനായി, ഫിൽട്ടർ നമ്മെ വഞ്ചിച്ചിട്ടില്ലെന്ന് ഉറപ്പാക്കാം (ഫിൽട്ടറുകൾ ഒരിക്കലും കള്ളം പറയില്ല!) കൂടാതെ "പരാജയപ്പെടാത്ത"വയുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുക:

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result='SUCCESS']

വിജയിക്കാത്തവയുടെ ലിസ്റ്റിന്റെ സ്ക്രീൻഷോട്ട്

റിമോട്ട് സെർവറിലെ ഒരു ഫോൾഡറിൽ നിന്നുള്ള പതിപ്പുകളുടെ ലിസ്റ്റ്

പതിപ്പുകളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കാൻ രണ്ടാമത്തെ വഴിയുണ്ട്. Jenkins API ആക്‌സസ് ചെയ്യുന്നതിനേക്കാൾ എനിക്ക് ഇത് ഇഷ്ടമാണ്. ശരി, കാരണം ആപ്ലിക്കേഷൻ വിജയകരമായി നിർമ്മിച്ചതാണെങ്കിൽ, അത് പാക്കേജുചെയ്ത് ഉചിതമായ ഫോൾഡറിലെ റിപ്പോസിറ്ററിയിൽ സ്ഥാപിച്ചുവെന്നാണ് ഇതിനർത്ഥം. അതുപോലെ, ആപ്ലിക്കേഷനുകളുടെ വർക്കിംഗ് പതിപ്പുകളുടെ ഡിഫോൾട്ട് സ്റ്റോറേജാണ് റിപ്പോസിറ്ററി. ഇഷ്ടപ്പെടുക. ശരി, സ്റ്റോറേജിലുള്ള പതിപ്പുകൾ ഏതൊക്കെയാണെന്ന് നമുക്ക് അവനോട് ചോദിക്കാം. ഞങ്ങൾ റിമോട്ട് ഫോൾഡർ ചുരുട്ടും, grep, awk ചെയ്യും. ആർക്കെങ്കിലും വൺലൈനറിൽ താൽപ്പര്യമുണ്ടെങ്കിൽ, അത് സ്‌പോയിലറിന് കീഴിലാണ്.

ഒരു വരി കമാൻഡ്
ദയവായി രണ്ട് കാര്യങ്ങൾ ശ്രദ്ധിക്കുക: ഞാൻ കണക്ഷൻ വിശദാംശങ്ങൾ തലക്കെട്ടിൽ നൽകുന്നു, ഫോൾഡറിൽ നിന്നുള്ള എല്ലാ പതിപ്പുകളും എനിക്ക് ആവശ്യമില്ല, ഒരു മാസത്തിനുള്ളിൽ സൃഷ്ടിച്ചവ മാത്രം ഞാൻ തിരഞ്ഞെടുക്കുന്നു. നിങ്ങളുടെ യാഥാർത്ഥ്യങ്ങൾക്കും ആവശ്യങ്ങൾക്കും അനുയോജ്യമായ കമാൻഡ് എഡിറ്റ് ചെയ്യുക:

curl -H "X-JFrog-Art-Api:VeryLongAPIKey" -s http://arts.myre.po/artifactory/awesomeapp/ | sed 's/a href=//' | grep "$(date +%b)-$(date +%Y)|$(date +%b --date='-1 month')-$(date +%Y)" | awk '{print $1}' | grep -oP '>K[^/]+' )

ജെങ്കിൻസിൽ ജോലികളും ജോലി കോൺഫിഗറേഷൻ ഫയലും സജ്ജീകരിക്കുന്നു

പതിപ്പുകളുടെ ലിസ്റ്റിന്റെ ഉറവിടം ഞങ്ങൾ കണ്ടെത്തി. ഇപ്പോൾ ലഭിച്ച ലിസ്റ്റ് ടാസ്ക്കിൽ ഉൾപ്പെടുത്താം. എന്നെ സംബന്ധിച്ചിടത്തോളം, ആപ്ലിക്കേഷൻ ബിൽഡ് ടാസ്ക്കിൽ ഒരു ഘട്ടം ചേർക്കുക എന്നതായിരുന്നു വ്യക്തമായ പരിഹാരം. ഫലം "വിജയം" ആണെങ്കിൽ നടപ്പിലാക്കുന്ന ഘട്ടം.

അസംബ്ലി ടാസ്‌ക് ക്രമീകരണങ്ങൾ തുറന്ന് ഏറ്റവും താഴേക്ക് സ്ക്രോൾ ചെയ്യുക. ബട്ടണുകളിൽ ക്ലിക്ക് ചെയ്യുക: ബിൽഡ് സ്റ്റെപ്പ് ചേർക്കുക -> സോപാധിക ഘട്ടം (ഒറ്റ). ഘട്ടം ക്രമീകരണങ്ങളിൽ, വ്യവസ്ഥ തിരഞ്ഞെടുക്കുക നിലവിലെ നിർമ്മാണ നില, മൂല്യം സജ്ജമാക്കുക വിജയം, വിജയിച്ചാൽ ചെയ്യേണ്ട പ്രവർത്തനം ഷെൽ കമാൻഡ് പ്രവർത്തിപ്പിക്കുക.

ഇപ്പോൾ രസകരമായ ഭാഗം. Jenkins ജോലി കോൺഫിഗറേഷനുകൾ ഫയലുകളിൽ സംഭരിക്കുന്നു. XML ഫോർമാറ്റിൽ. വഴിയിൽ http://путь-до-задания/config.xml അതനുസരിച്ച്, നിങ്ങൾക്ക് കോൺഫിഗറേഷൻ ഫയൽ ഡൗൺലോഡ് ചെയ്യാനും ആവശ്യാനുസരണം എഡിറ്റ് ചെയ്യാനും കിട്ടിയിടത്ത് തന്നെ തിരികെ വയ്ക്കാനും കഴിയും.

പതിപ്പുകളുടെ ലിസ്റ്റിനായി ഞങ്ങൾ ഒരു പാരാമീറ്റർ സൃഷ്ടിക്കുമെന്ന് ഞങ്ങൾ മുകളിൽ സമ്മതിച്ചുവെന്ന് ഓർമ്മിക്കുക BUILD_VERSION?

നമുക്ക് കോൺഫിഗറേഷൻ ഫയൽ ഡൗൺലോഡ് ചെയ്ത് അതിനുള്ളിൽ നോക്കാം. പരാമീറ്റർ സ്ഥലത്താണെന്നും ആവശ്യമുള്ള തരത്തിലാണെന്നും ഉറപ്പാക്കാൻ മാത്രം.

സ്‌പോയിലറിന് കീഴിലുള്ള സ്‌ക്രീൻഷോട്ട്.

നിങ്ങളുടെ config.xml ശകലം സമാനമായിരിക്കണം. ചോയ്‌സ് എലമെന്റിന്റെ ഉള്ളടക്കം ഇതുവരെ കാണുന്നില്ല എന്നതൊഴിച്ചാൽ

നിങ്ങൾക്ക് ഉറപ്പാണോ? അത്രയേയുള്ളൂ, ബിൽഡ് വിജയിച്ചാൽ എക്സിക്യൂട്ട് ചെയ്യുന്ന ഒരു സ്ക്രിപ്റ്റ് എഴുതാം.
സ്ക്രിപ്റ്റിന് പതിപ്പുകളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കും, കോൺഫിഗറേഷൻ ഫയൽ ഡൗൺലോഡ് ചെയ്യുക, നമുക്ക് ആവശ്യമുള്ള സ്ഥലത്ത് പതിപ്പുകളുടെ ലിസ്റ്റ് എഴുതുക, തുടർന്ന് അത് തിരികെ വയ്ക്കുക. അതെ. അത് ശരിയാണ്. പതിപ്പുകളുടെ ഒരു ലിസ്റ്റ് ഇതിനകം ഉള്ള സ്ഥലത്ത് XML-ൽ പതിപ്പുകളുടെ ഒരു ലിസ്റ്റ് എഴുതുക (സ്ക്രിപ്റ്റിന്റെ ആദ്യ ലോഞ്ചിന് ശേഷം ഭാവിയിൽ ആയിരിക്കും). ലോകത്ത് ഇപ്പോഴും പതിവ് ആവിഷ്കാരങ്ങൾക്ക് കടുത്ത ആരാധകർ ഉണ്ടെന്ന് എനിക്കറിയാം. ഞാൻ അവരുടേതല്ല. ദയവായി ഇൻസ്റ്റാൾ ചെയ്യുക xmlstarler കോൺഫിഗറേഷൻ എഡിറ്റ് ചെയ്യുന്ന മെഷീനിലേക്ക്. സെഡ് ഉപയോഗിച്ച് XML എഡിറ്റുചെയ്യുന്നത് ഒഴിവാക്കാൻ ഇത് അത്ര വലിയ വിലയല്ലെന്ന് എനിക്ക് തോന്നുന്നു.

സ്‌പോയിലറിന് കീഴിൽ, മേൽപ്പറഞ്ഞ ക്രമം പൂർണ്ണമായും നിർവഹിക്കുന്ന കോഡ് ഞാൻ അവതരിപ്പിക്കുന്നു.

വിദൂര സെർവറിലെ ഒരു ഫോൾഡറിൽ നിന്ന് കോൺഫിഗറിലേക്ക് പതിപ്പുകളുടെ ഒരു ലിസ്റ്റ് എഴുതുക

#!/bin/bash
############## Скачиваем конфиг
curl -X GET -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml -o appConfig.xml

############## Удаляем и заново создаем xml-элемент для списка версий
xmlstarlet ed --inplace -d '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' appConfig.xml

xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]' --type elem -n a appConfig.xml

xmlstarlet ed --inplace --insert '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a' --type attr -n class -v string-array appConfig.xml

############## Читаем в массив список версий из репозитория
readarray -t vers < <( curl -H "X-JFrog-Art-Api:Api:VeryLongAPIKey" -s http://arts.myre.po/artifactory/awesomeapp/ | sed 's/a href=//' | grep "$(date +%b)-$(date +%Y)|$(date +%b --date='-1 month')-$(date +%Y)" | awk '{print $1}' | grep -oP '>K[^/]+' )

############## Пишем массив элемент за элементом в конфиг
printf '%sn' "${vers[@]}" | sort -r | 
                while IFS= read -r line
                do
                    xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' --type elem -n string -v "$line" appConfig.xml
                done

############## Кладем конфиг взад
curl -X POST -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml --data-binary @appConfig.xml

############## Приводим рабочее место в порядок
rm -f appConfig.xml

ജെൻകിൻസിൽ നിന്ന് പതിപ്പുകൾ നേടുന്നതിനുള്ള ഓപ്ഷൻ നിങ്ങൾ തിരഞ്ഞെടുക്കുകയും എന്നെപ്പോലെ മടിയനാണെങ്കിൽ, സ്‌പോയിലറിന് കീഴിൽ അതേ കോഡാണ്, പക്ഷേ ജെങ്കിൻസിൽ നിന്നുള്ള ഒരു ലിസ്റ്റ്:

ജെങ്കിൻസ് മുതൽ കോൺഫിഗറേഷൻ വരെയുള്ള പതിപ്പുകളുടെ ഒരു ലിസ്റ്റ് എഴുതുക
ഇത് മനസ്സിൽ വയ്ക്കുക: എന്റെ അസംബ്ലി നാമത്തിൽ ഒരു കോളൻ കൊണ്ട് വേർതിരിച്ച ഒരു സീക്വൻസ് നമ്പറും ഒരു പതിപ്പ് നമ്പറും അടങ്ങിയിരിക്കുന്നു. അതനുസരിച്ച്, awk അനാവശ്യമായ ഭാഗം മുറിച്ചുമാറ്റുന്നു. നിങ്ങൾക്കായി, നിങ്ങളുടെ ആവശ്യങ്ങൾക്കനുസരിച്ച് ഈ വരി മാറ്റുക.

#!/bin/bash
############## Скачиваем конфиг
curl -X GET -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml -o appConfig.xml

############## Удаляем и заново создаем xml-элемент для списка версий
xmlstarlet ed --inplace -d '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' appConfig.xml

xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]' --type elem -n a appConfig.xml

xmlstarlet ed --inplace --insert '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a' --type attr -n class -v string-array appConfig.xml

############## Пишем в файл список версий из Jenkins
curl -g -X GET -u username:apiKey 'http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!=%22SUCCESS%22]&pretty=true' -o builds.xml

############## Читаем в массив список версий из XML
readarray vers < <(xmlstarlet sel -t -v "freeStyleProject/allBuild/displayName" builds.xml | awk -F":" '{print $2}')

############## Пишем массив элемент за элементом в конфиг
printf '%sn' "${vers[@]}" | sort -r | 
                while IFS= read -r line
                do
                    xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' --type elem -n string -v "$line" appConfig.xml
                done

############## Кладем конфиг взад
curl -X POST -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml --data-binary @appConfig.xml

############## Приводим рабочее место в порядок
rm -f appConfig.xml

സിദ്ധാന്തത്തിൽ, മുകളിലുള്ള ഉദാഹരണങ്ങളെ അടിസ്ഥാനമാക്കി എഴുതിയ കോഡ് നിങ്ങൾ പരീക്ഷിച്ചിട്ടുണ്ടെങ്കിൽ, വിന്യാസ ടാസ്ക്കിൽ നിങ്ങൾക്ക് ഇതിനകം പതിപ്പുകളുള്ള ഒരു ഡ്രോപ്പ്-ഡൗൺ ലിസ്റ്റ് ഉണ്ടായിരിക്കണം. സ്‌പോയിലറിന് കീഴിലുള്ള സ്‌ക്രീൻഷോട്ടിലെ പോലെയാണിത്.

പതിപ്പുകളുടെ ശരിയായി പൂർത്തിയാക്കിയ ലിസ്റ്റ്

എല്ലാം പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ, സ്ക്രിപ്റ്റ് പകർത്തി ഒട്ടിക്കുക ഷെൽ കമാൻഡ് പ്രവർത്തിപ്പിക്കുക കൂടാതെ മാറ്റങ്ങൾ സംരക്ഷിക്കുക.

ക്ലൗഡ് ഷെല്ലിലേക്ക് ബന്ധിപ്പിക്കുന്നു

ഞങ്ങൾക്ക് കണ്ടെയ്‌നറുകളിൽ കളക്ടർമാരുണ്ട്. ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ ഡെലിവറി ഉപകരണമായും കോൺഫിഗറേഷൻ മാനേജറായും ഞങ്ങൾ അൻസിബിൾ ഉപയോഗിക്കുന്നു. അതനുസരിച്ച്, കണ്ടെയ്‌നറുകൾ നിർമ്മിക്കുമ്പോൾ, മൂന്ന് ഓപ്ഷനുകൾ മനസ്സിൽ വരുന്നു: ഡോക്കറിൽ ഡോക്കർ ഇൻസ്റ്റാൾ ചെയ്യുക, അൻസിബിൾ പ്രവർത്തിക്കുന്ന മെഷീനിൽ ഡോക്കർ ഇൻസ്റ്റാൾ ചെയ്യുക, അല്ലെങ്കിൽ ഒരു ക്ലൗഡ് കൺസോളിൽ കണ്ടെയ്‌നറുകൾ നിർമ്മിക്കുക. ഈ ലേഖനത്തിൽ ജെങ്കിൻസിന്റെ പ്ലഗിന്നുകളെ കുറിച്ച് മൗനം പാലിക്കാൻ ഞങ്ങൾ സമ്മതിച്ചു. ഓർക്കുന്നുണ്ടോ?

ഞാൻ തീരുമാനിച്ചു: ശരി, "ബോക്സിന് പുറത്ത്" കണ്ടെയ്നറുകൾ ക്ലൗഡ് കൺസോളിൽ ശേഖരിക്കാൻ കഴിയുമെന്നതിനാൽ, പിന്നെ എന്തിനാണ് വിഷമിക്കേണ്ടത്? വൃത്തിയായി സൂക്ഷിക്കുക, അല്ലേ? എനിക്ക് ക്ലൗഡ് കൺസോളിൽ ജെങ്കിൻസ് കണ്ടെയ്‌നറുകൾ ശേഖരിക്കണം, തുടർന്ന് അവ അവിടെ നിന്ന് ക്യൂബറിലേക്ക് ലോഞ്ച് ചെയ്യണം. മാത്രമല്ല, ഗൂഗിളിന്റെ ഇൻഫ്രാസ്ട്രക്ചറിനുള്ളിൽ വളരെ സമ്പന്നമായ ചാനലുകൾ ഉണ്ട്, അത് വിന്യാസത്തിന്റെ വേഗതയിൽ ഗുണം ചെയ്യും.

ക്ലൗഡ് കൺസോളിലേക്ക് കണക്റ്റുചെയ്യുന്നതിന്, നിങ്ങൾക്ക് രണ്ട് കാര്യങ്ങൾ ആവശ്യമാണ്: gCloud കൂടാതെ ആക്സസ് അവകാശങ്ങളും Google ക്ലൗഡ് API ഇതേ കണക്ഷൻ ഉണ്ടാക്കുന്ന VM ഉദാഹരണത്തിനായി.

ഗൂഗിൾ ക്ലൗഡിൽ നിന്നല്ല കണക്റ്റ് ചെയ്യാൻ ഉദ്ദേശിക്കുന്നവർക്ക്
Google അതിന്റെ സേവനങ്ങളിൽ സംവേദനാത്മക അംഗീകാരം പ്രവർത്തനരഹിതമാക്കാനുള്ള സാധ്യത അനുവദിക്കുന്നു. ഒരു കോഫി മെഷീനിൽ നിന്ന് പോലും കൺസോളിലേക്ക് കണക്റ്റുചെയ്യാൻ ഇത് നിങ്ങളെ അനുവദിക്കും, അത് *nix പ്രവർത്തിക്കുകയും ഒരു കൺസോൾ തന്നെയുണ്ടെങ്കിൽ.

ഈ കുറിപ്പിന്റെ ചട്ടക്കൂടിനുള്ളിൽ ഞാൻ ഈ വിഷയം കൂടുതൽ വിശദമായി കവർ ചെയ്യേണ്ട ആവശ്യമുണ്ടെങ്കിൽ, അഭിപ്രായങ്ങളിൽ എഴുതുക. ഞങ്ങൾക്ക് മതിയായ വോട്ടുകൾ ലഭിക്കുകയാണെങ്കിൽ, ഈ വിഷയത്തിൽ ഞാൻ ഒരു അപ്ഡേറ്റ് എഴുതാം.

അവകാശങ്ങൾ നൽകാനുള്ള എളുപ്പവഴി വെബ് ഇന്റർഫേസിലൂടെയാണ്.

1. നിങ്ങൾ പിന്നീട് ക്ലൗഡ് കൺസോളിലേക്ക് കണക്റ്റുചെയ്യുന്ന VM ഇൻസ്‌റ്റൻസ് നിർത്തുക.
2. ഉദാഹരണ വിശദാംശങ്ങൾ തുറന്ന് ക്ലിക്കുചെയ്യുക ഭേദഗതി വരുത്തുക.
3. പേജിന്റെ ഏറ്റവും താഴെ, ഇൻസ്റ്റൻസ് ആക്സസ് സ്കോപ്പ് തിരഞ്ഞെടുക്കുക എല്ലാ ക്ലൗഡ് API-കളിലേക്കും പൂർണ്ണ ആക്സസ്.

   സ്ക്രീൻഷോട്ട്
   

4. നിങ്ങളുടെ മാറ്റങ്ങൾ സംരക്ഷിച്ച് ഉദാഹരണം സമാരംഭിക്കുക.

VM ലോഡിംഗ് പൂർത്തിയാക്കിക്കഴിഞ്ഞാൽ, SSH വഴി അതിലേക്ക് കണക്റ്റുചെയ്‌ത് ഒരു പിശക് കൂടാതെ കണക്ഷൻ സംഭവിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക. കമാൻഡ് ഉപയോഗിക്കുക:

gcloud alpha cloud-shell ssh

വിജയകരമായ ഒരു കണക്ഷൻ ഇതുപോലെ കാണപ്പെടുന്നു

GKE-ലേക്ക് വിന്യസിക്കുക

IaC-ലേക്ക് (ഇൻഫ്രാസ്ട്രക്ചർ ഒരു കോഡായി) മാറാൻ സാധ്യമായ എല്ലാ വഴികളിലും ഞങ്ങൾ ശ്രമിക്കുന്നതിനാൽ, ഞങ്ങളുടെ ഡോക്കർഫയലുകൾ Git-ൽ സംഭരിച്ചിരിക്കുന്നു. ഇത് ഒരു വശത്ത്. കൂടാതെ kubernetes-ലെ വിന്യാസം ഒരു yaml ഫയലാണ് വിവരിക്കുന്നത്, ഇത് ഈ ടാസ്‌ക്കിന് മാത്രം ഉപയോഗിക്കുന്നു, അത് കോഡ് പോലെയാണ്. ഇത് മറുവശത്ത് നിന്നാണ്. പൊതുവേ, ഞാൻ ഉദ്ദേശിക്കുന്നത്, പദ്ധതി ഇതാണ്:

1. ഞങ്ങൾ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ എടുക്കുന്നു BUILD_VERSION കൂടാതെ, ഓപ്ഷണലായി, കടന്നുപോകുന്ന വേരിയബിളുകളുടെ മൂല്യങ്ങൾ ENV.
2. Git-ൽ നിന്ന് ഡോക്കർഫയൽ ഡൗൺലോഡ് ചെയ്യുക.
3. വിന്യാസത്തിനായി യാമൽ ഉണ്ടാക്കുക.
4. ഞങ്ങൾ ഈ രണ്ട് ഫയലുകളും scp വഴി ക്ലൗഡ് കൺസോളിലേക്ക് അപ്‌ലോഡ് ചെയ്യുന്നു.
5. ഞങ്ങൾ അവിടെ ഒരു കണ്ടെയ്നർ നിർമ്മിക്കുകയും കണ്ടെയ്നർ രജിസ്ട്രിയിലേക്ക് തള്ളുകയും ചെയ്യുന്നു
6. ഞങ്ങൾ ലോഡ് വിന്യാസ ഫയൽ ക്യൂബറിലേക്ക് പ്രയോഗിക്കുന്നു.

നമുക്ക് കൂടുതൽ വ്യക്തമായി പറയാം. ഒരിക്കൽ ഞങ്ങൾ സംസാരിച്ചു തുടങ്ങി ENV, അപ്പോൾ നമുക്ക് രണ്ട് പാരാമീറ്ററുകളുടെ മൂല്യങ്ങൾ കൈമാറേണ്ടതുണ്ടെന്ന് കരുതുക: പരം 1 и പരം 2. വിന്യാസത്തിനായി ഞങ്ങൾ അവരുടെ ചുമതല ചേർക്കുന്നു, ടൈപ്പ് ചെയ്യുക - സ്ട്രിംഗ് പാരാമീറ്റർ.

സ്ക്രീൻഷോട്ട്

ഒരു ലളിതമായ റീഡയറക്ഷൻ ഉപയോഗിച്ച് ഞങ്ങൾ yaml സൃഷ്ടിക്കും എക്കോ ഫയൽ ചെയ്യാൻ. തീർച്ചയായും, നിങ്ങളുടെ ഡോക്കർഫയലിൽ ഉണ്ടെന്ന് അനുമാനിക്കപ്പെടുന്നു പരം 1 и പരം 2ലോഡ് നെയിം ആയിരിക്കും എന്ന് ആകർഷണീയമായ അപ്ലിക്കേഷൻ, കൂടാതെ നിർദ്ദിഷ്ട പതിപ്പിന്റെ പ്രയോഗത്തോടുകൂടിയ അസംബിൾ ചെയ്ത കണ്ടെയ്‌നർ അടങ്ങിയിരിക്കുന്നു കണ്ടെയ്നർ രജിസ്ട്രി വഴിയിൽ gcr.io/awesomeapp/awesomeapp-$BUILD_VERSIONഎവിടെ $BUILD_VERSION ഡ്രോപ്പ്-ഡൗൺ ലിസ്റ്റിൽ നിന്ന് തിരഞ്ഞെടുത്തു.

ടീം ലിസ്റ്റിംഗ്

touch deploy.yaml
echo "apiVersion: apps/v1" >> deploy.yaml
echo "kind: Deployment" >> deploy.yaml
echo "metadata:" >> deploy.yaml
echo "  name: awesomeapp" >> deploy.yaml
echo "spec:" >> deploy.yaml
echo "  replicas: 1" >> deploy.yaml
echo "  selector:" >> deploy.yaml
echo "    matchLabels:" >> deploy.yaml
echo "      run: awesomeapp" >> deploy.yaml
echo "  template:" >> deploy.yaml
echo "    metadata:" >> deploy.yaml
echo "      labels:" >> deploy.yaml
echo "        run: awesomeapp" >> deploy.yaml
echo "    spec:" >> deploy.yaml
echo "      containers:" >> deploy.yaml
echo "      - name: awesomeapp" >> deploy.yaml
echo "        image: gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION:latest" >> deploy.yaml
echo "        env:" >> deploy.yaml
echo "        - name: PARAM1" >> deploy.yaml
echo "          value: $PARAM1" >> deploy.yaml
echo "        - name: PARAM2" >> deploy.yaml
echo "          value: $PARAM2" >> deploy.yaml

ഉപയോഗിച്ചതിന് ശേഷം Jenkins ഏജന്റ് gcloud ആൽഫ ക്ലൗഡ്-ഷെൽ ssh സംവേദനാത്മക മോഡ് ലഭ്യമല്ല, അതിനാൽ പാരാമീറ്റർ ഉപയോഗിച്ച് ഞങ്ങൾ ക്ലൗഡ് കൺസോളിലേക്ക് കമാൻഡുകൾ അയയ്ക്കുന്നു --കമാൻഡ്.

പഴയ ഡോക്കർഫയലിൽ നിന്ന് ഞങ്ങൾ ക്ലൗഡ് കൺസോളിലെ ഹോം ഫോൾഡർ വൃത്തിയാക്കുന്നു:

gcloud alpha cloud-shell ssh --command="rm -f Dockerfile"

scp ഉപയോഗിച്ച് ക്ലൗഡ് കൺസോളിന്റെ ഹോം ഫോൾഡറിൽ പുതുതായി ഡൗൺലോഡ് ചെയ്ത ഡോക്കർഫയൽ സ്ഥാപിക്കുക:

gcloud alpha cloud-shell scp localhost:./Dockerfile cloudshell:~

ഞങ്ങൾ കണ്ടെയ്നർ ശേഖരിക്കുകയും ടാഗ് ചെയ്യുകയും കണ്ടെയ്നർ രജിസ്ട്രിയിലേക്ക് തള്ളുകയും ചെയ്യുന്നു:

gcloud alpha cloud-shell ssh --command="docker build -t awesomeapp-$BUILD_VERSION ./ --build-arg BUILD_VERSION=$BUILD_VERSION --no-cache"
gcloud alpha cloud-shell ssh --command="docker tag awesomeapp-$BUILD_VERSION gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION"
gcloud alpha cloud-shell ssh --command="docker push gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION"

വിന്യാസ ഫയലിലും ഞങ്ങൾ ഇത് തന്നെ ചെയ്യുന്നു. താഴെയുള്ള കമാൻഡുകൾ വിന്യാസം നടക്കുന്ന ക്ലസ്റ്ററിന്റെ സാങ്കൽപ്പിക പേരുകൾ ഉപയോഗിക്കുന്നുവെന്നത് ശ്രദ്ധിക്കുക (awsm-ക്ലസ്റ്റർ) കൂടാതെ പദ്ധതിയുടെ പേര് (ആകർഷണീയമായ-പദ്ധതി), ക്ലസ്റ്റർ എവിടെയാണ് സ്ഥിതി ചെയ്യുന്നത്.

gcloud alpha cloud-shell ssh --command="rm -f deploy.yaml"
gcloud alpha cloud-shell scp localhost:./deploy.yaml cloudshell:~
gcloud alpha cloud-shell ssh --command="gcloud container clusters get-credentials awsm-cluster --zone us-central1-c --project awesome-project && 
kubectl apply -f deploy.yaml"

ഞങ്ങൾ ടാസ്ക് പ്രവർത്തിപ്പിക്കുകയും കൺസോൾ ഔട്ട്പുട്ട് തുറക്കുകയും കണ്ടെയ്നറിന്റെ വിജയകരമായ അസംബ്ലി കാണുമെന്ന് പ്രതീക്ഷിക്കുകയും ചെയ്യുന്നു.

സ്ക്രീൻഷോട്ട്

തുടർന്ന് കൂട്ടിച്ചേർത്ത കണ്ടെയ്നറിന്റെ വിജയകരമായ വിന്യാസം

സ്ക്രീൻഷോട്ട്

ക്രമീകരണം ഞാൻ മനഃപൂർവം അവഗണിച്ചു തുടരുക. ഒരു ലളിതമായ കാരണത്താൽ: നിങ്ങൾ അത് സജ്ജീകരിച്ചുകഴിഞ്ഞാൽ ജോലിഭാരം നൽകിയിരിക്കുന്ന പേരിൽ, നിങ്ങൾ ഈ പേരിൽ എത്ര വിന്യാസങ്ങൾ നടത്തിയാലും അത് പ്രവർത്തനക്ഷമമായി തുടരും. ശരി, പൊതുവേ, ഇത് ചരിത്രത്തിന്റെ പരിധിക്കപ്പുറമാണ്.

നിഗമനങ്ങൾക്ക് പകരം

മുകളിലുള്ള എല്ലാ ഘട്ടങ്ങളും ഒരുപക്ഷേ ചെയ്യാൻ കഴിയില്ല, പക്ഷേ ജെൻകിൻസിന് അവരുടെ മ്യൂലിയോൺ ചില പ്ലഗിൻ ഇൻസ്റ്റാൾ ചെയ്തു. എന്നാൽ ചില കാരണങ്ങളാൽ എനിക്ക് പ്ലഗിനുകൾ ഇഷ്ടമല്ല. ശരി, കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, നിരാശയിൽ നിന്ന് മാത്രമാണ് ഞാൻ അവരെ ആശ്രയിക്കുന്നത്.

എനിക്കായി എന്തെങ്കിലും പുതിയ വിഷയം എടുക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. തുടക്കത്തിൽ വിവരിച്ച പ്രശ്നം പരിഹരിക്കുന്നതിനിടയിൽ ഞാൻ കണ്ടെത്തിയ കണ്ടെത്തലുകൾ പങ്കിടുന്നതിനുള്ള ഒരു മാർഗമാണ് മുകളിലെ വാചകം. അവനെപ്പോലെ, devops-ൽ ഒട്ടും മോശമല്ലാത്ത ചെന്നായ അല്ലാത്തവരുമായി പങ്കിടുക. എന്റെ കണ്ടെത്തലുകൾ ആരെയെങ്കിലും സഹായിച്ചാൽ, ഞാൻ സന്തോഷിക്കും.

അവലംബം: www.habr.com