ഒരു ജെങ്കിൻസ് ജോലിയിൽ ഡൈനാമിക് പാരാമീറ്ററുകൾ സൃഷ്ടിക്കുന്നു, അല്ലെങ്കിൽ നിങ്ങളുടെ ടാസ്‌ക് എങ്ങനെ ഉപയോക്തൃ-സൗഹൃദമാക്കാം

ശുഭദിനം, ഹബ്ർ!

ഇന്ന് ഞാൻ ഉപയോഗിക്കാനുള്ള വഴികളിൽ ഒന്ന് പങ്കിടാൻ ആഗ്രഹിക്കുന്നു സജീവ ചോയ്‌സ് പ്ലഗിൻ ചുമതല നിർവഹിക്കുക ജെങ്കിൻസ് ഏറ്റവും ഏകീകൃതവും ഉപയോക്തൃ സൗഹൃദവുമാണ്.

ആമുഖം

DevOps എന്ന അത്തരമൊരു ചുരുക്കെഴുത്ത് ഐടി കമ്മ്യൂണിറ്റിക്ക് ഇനി പുതിയ കാര്യമല്ല. പലർക്കും, "DevOps" എന്ന വാക്യം ഏതെങ്കിലും തരത്തിലുള്ള മാജിക് ബട്ടണുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു, ക്ലിക്ക് ചെയ്യുമ്പോൾ, ആപ്ലിക്കേഷൻ കോഡ് സ്വയമേവ വിന്യസിച്ചതും പരീക്ഷിച്ചതുമായ ആപ്ലിക്കേഷനായി മാറുന്നു (എല്ലാം യഥാർത്ഥത്തിൽ കൂടുതൽ സങ്കീർണ്ണമാണ്, പക്ഷേ ഞങ്ങൾ എല്ലാ പ്രക്രിയകളിൽ നിന്നും അമൂർത്തമാണ്).

അതിനാൽ, അഡ്‌മിനിസ്‌ട്രേറ്റർമാർക്ക് ഒറ്റ ക്ലിക്കിൽ ആപ്ലിക്കേഷൻ വിന്യസിക്കാൻ കഴിയുന്ന തരത്തിൽ അത്തരമൊരു മാജിക് ബട്ടൺ നിർമ്മിക്കാനുള്ള ഓർഡർ ഞങ്ങൾക്ക് ലഭിച്ചു. ഈ ടാസ്‌ക് നടപ്പിലാക്കുന്നതിന് വിവിധ തരങ്ങളുണ്ട്: ഏതെങ്കിലും തൽക്ഷണ സന്ദേശവാഹകർക്കായി ഒരു ബോട്ട് എഴുതുന്നത് മുതൽ ഒരു പ്രത്യേക ആപ്ലിക്കേഷൻ വികസിപ്പിക്കുന്നത് വരെ. എന്നിരുന്നാലും, ഇതിനെല്ലാം ഒരേ ലക്ഷ്യമുണ്ട് - ആപ്ലിക്കേഷന്റെ നിർമ്മാണവും വിന്യാസവും ആരംഭിക്കുന്നത് കഴിയുന്നത്ര സുതാര്യവും സൗകര്യപ്രദവുമാക്കുക.

ഞങ്ങളുടെ കാര്യത്തിൽ ഞങ്ങൾ ഉപയോഗിക്കും ജെങ്കിൻസ്.

ലക്ഷ്യം

ഒരു നിശ്ചിത പതിപ്പിന്റെ തിരഞ്ഞെടുത്ത മൈക്രോസർവീസിന്റെ നിർമ്മാണവും (അല്ലെങ്കിൽ) വിന്യാസവും സമാരംഭിക്കുന്ന ഒരു സൗകര്യപ്രദമായ ജെങ്കിൻസ് ജോലി സൃഷ്ടിക്കുക.

ഇൻപുട്ട് ഡാറ്റ

വിവിധ മൈക്രോസർവീസുകളുടെ സോഴ്സ് കോഡ് അടങ്ങുന്ന നിരവധി റിപ്പോസിറ്ററികൾ ഞങ്ങളുടെ പക്കലുണ്ട്.

പാരാമീറ്ററുകൾ നിർവചിക്കുന്നു

ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ ഞങ്ങളുടെ ജോലിയുടെ ഇൻപുട്ടായി സ്വീകരിക്കണം:

1. ജോലി പ്രവർത്തിപ്പിക്കുമ്പോൾ ഞങ്ങൾ നിർമ്മിക്കാനും വിന്യസിക്കാനും ആഗ്രഹിക്കുന്ന മൈക്രോസർവീസ് കോഡുള്ള റിപ്പോസിറ്ററിയുടെ URL.
2. നിർമ്മാണം സംഭവിക്കുന്ന പ്രതിബദ്ധതയുടെ ഐഡി.

അതു പൊലെ

ഈ ടാസ്ക് നിർവ്വഹിക്കുന്നതിനുള്ള ഏറ്റവും എളുപ്പമുള്ള മാർഗ്ഗം, ടൈപ്പ് സ്ട്രിംഗ് രണ്ട് പാരാമീറ്ററുകൾ സൃഷ്ടിക്കുക എന്നതാണ്.

ഈ സാഹചര്യത്തിൽ, ഉപയോക്താവ് റിപ്പോസിറ്ററിയിലേക്കും കമ്മിറ്റ് ഐഡിയിലേക്കുമുള്ള പാത സ്വമേധയാ നൽകേണ്ടതുണ്ട്, അത് പൂർണ്ണമായും സൗകര്യപ്രദമല്ല.

ആകേണ്ടതിന്നു

ഇപ്പോൾ അതിന്റെ എല്ലാ ഗുണങ്ങളും പരിഗണിക്കുന്നതിന് മറ്റൊരു തരം പാരാമീറ്ററുകൾ പരീക്ഷിക്കാം.
ചോയ്‌സ് പാരാമീറ്റർ തരം ഉപയോഗിച്ച് ആദ്യ പാരാമീറ്റർ സൃഷ്ടിക്കാം, രണ്ടാമത്തേത് - സജീവ ചോയ്‌സുകൾ റിയാക്ടീവ് റഫറൻസ് പാരാമീറ്റർ. ചോയ്‌സ് തരം ഉള്ള പരാമീറ്ററിൽ, ഞങ്ങളുടെ മൈക്രോസർവീസുകളുടെ കോഡ് സംഭരിച്ചിരിക്കുന്ന റിപ്പോസിറ്ററികളുടെ പേരുകൾ ചോയ്‌സ് ഫീൽഡിൽ ഞങ്ങൾ സ്വമേധയാ ചേർക്കും.

പ്രേക്ഷകർക്ക് ഈ ലേഖനം ഇഷ്ടമാണെങ്കിൽ, അടുത്ത ലേഖനത്തിൽ, കോഡിലൂടെയുള്ള ഒരു വിവരണം (കോഡായി കോൺഫിഗറേഷൻ) ഉപയോഗിച്ച് ജെൻകിൻസിൽ ടാസ്‌ക്കുകൾ കോൺഫിഗർ ചെയ്യുന്ന പ്രക്രിയ ഞാൻ വിവരിക്കും, അതായത്. നമുക്ക് സ്വമേധയാ റിപ്പോസിറ്ററി നാമങ്ങൾ നൽകേണ്ടതില്ല, പാരാമീറ്ററുകൾ സൃഷ്ടിക്കേണ്ടതില്ല, എല്ലാം യാന്ത്രികമായി സംഭവിക്കും (ഞങ്ങളുടെ കോഡിന് SCM-ൽ നിന്ന് ശേഖരണങ്ങളുടെ ഒരു ലിസ്റ്റ് ലഭിക്കും കൂടാതെ ഈ ലിസ്റ്റിനൊപ്പം ഒരു പാരാമീറ്റർ സൃഷ്ടിക്കും).

ആദ്യ പാരാമീറ്റർ (ടെസ്റ്റ്1 അല്ലെങ്കിൽ ടെസ്റ്റ്2) എടുക്കുന്ന മൂല്യത്തെ ആശ്രയിച്ച് രണ്ടാമത്തെ പാരാമീറ്ററിന്റെ മൂല്യങ്ങൾ ചലനാത്മകമായി പൂരിപ്പിക്കും, കാരണം ഓരോ ശേഖരത്തിനും അതിന്റേതായ കമ്മിറ്റുകളുടെ പട്ടികയുണ്ട്.

സജീവ ചോയ്‌സുകൾ റിയാക്ടീവ് റഫറൻസ് പാരാമീറ്റർ പൂരിപ്പിക്കുന്നതിന് ഇനിപ്പറയുന്ന ഫീൽഡുകൾ ഉണ്ട്:

1. പേര് - പാരാമീറ്റർ പേര്.
2. സ്ക്രിപ്റ്റ് - റഫറൻസ് ചെയ്‌ത പാരാമീറ്റർ ഫീൽഡിൽ നിന്നുള്ള പാരാമീറ്ററിന്റെ മൂല്യം മാറ്റുമ്പോഴെല്ലാം എക്‌സിക്യൂട്ട് ചെയ്യുന്ന കോഡ് (ഞങ്ങളുടെ കാര്യത്തിൽ, ഞങ്ങൾ test1 നും test2 നും ഇടയിൽ തിരഞ്ഞെടുക്കുമ്പോൾ).
3. വിവരണം - പാരാമീറ്ററിന്റെ ഹ്രസ്വ വിവരണം.
4. ചോയ്സ് തരം - സ്ക്രിപ്റ്റ് നൽകുന്ന ഒബ്ജക്റ്റിന്റെ തരം (ഞങ്ങളുടെ കാര്യത്തിൽ ഞങ്ങൾ html കോഡ് നൽകും).
5. പരാമർശിച്ച പരാമീറ്റർ - പാരാമീറ്ററിന്റെ പേര്, അതിന്റെ മൂല്യം മാറ്റുമ്പോൾ, സ്ക്രിപ്റ്റ് വിഭാഗത്തിൽ നിന്നുള്ള കോഡ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും.

ഈ പരാമീറ്ററിലെ ഏറ്റവും പ്രധാനപ്പെട്ട ഫീൽഡ് പൂരിപ്പിക്കുന്നതിന് നമുക്ക് നേരിട്ട് പോകാം. തിരഞ്ഞെടുക്കാൻ ഞങ്ങൾക്ക് രണ്ട് തരം നടപ്പിലാക്കൽ വാഗ്ദാനം ചെയ്യുന്നു: ഉപയോഗിക്കുന്നത് ഗ്രോവി സ്ക്രിപ്റ്റ് അഥവാ സ്ക്രിപ്റ്റ്ലർ സ്ക്രിപ്റ്റ്.
ഞങ്ങൾ ആദ്യത്തേത് തിരഞ്ഞെടുക്കുന്നു, കാരണം നിങ്ങൾ മുമ്പ് എഴുതിയ സ്‌ക്രിപ്റ്റുകൾ സംരക്ഷിക്കുകയും വീണ്ടും കോപ്പി-പേസ്റ്റ് ചെയ്യാതെ തന്നെ മറ്റ് ടാസ്‌ക്കുകളിൽ അവ ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുകയും ചെയ്യുന്ന ഒരു പ്ലഗിൻ മാത്രമാണ് Scriptler.

തിരഞ്ഞെടുത്ത ശേഖരത്തിൽ നിന്ന് എല്ലാ കമ്മിറ്റുകളും ലഭിക്കുന്നതിനുള്ള ഗ്രൂവി കോഡ്:

AUTH = "логин и пароль в Base64"                           
GIT_URL = "url до вашей SCM (https://bitbucket.org/)"                       
PROJECT_NAME = "имя проектной области, где находятся репозитории"

def htmlBuild() {
    html = """
            <html>
            <head>
            <meta charset="windows-1251">
            <style type="text/css">
            div.grayTable {
            text-align: left;
            border-collapse: collapse;
            }
            .divTable.grayTable .divTableCell, .divTable.grayTable .divTableHead {
            padding: 0px 3px;
            }
            .divTable.grayTable .divTableBody .divTableCell {
            font-size: 13px;
            }
            </style>
            </head>
            <body>
        """

    def commitOptions = ""
    getCommitsForMicroservice(MICROSERVICE_NAME).each {
        commitOptions += "<option style='font-style: italic' value='COMMIT=${it.getKey()}'>${it}</option>"
    }
    html += """<p style="display: inline-block;">
        <select id="commit_id" size="1" name="value">
            ${commitOptions}
        </select></p></div>"""

    html += """
            </div>
            </div>
            </div>
            </body>
            </html>
         """
    return html
}

def getCommitsForMicroservice(microserviceRepo) {
    def commits = [:]
    def endpoint = GIT_URL + "/rest/api/1.0/projects/${PROJECT_NAME}/repos/${microserviceRepo}/commits"
    def conn = new URL(endpoint).openConnection()
    conn.setRequestProperty("Authorization", "Basic ${AUTH}")
    def response = new groovy.json.JsonSlurper().parseText(conn.content.text)
    response.values.each {
        commits.put(it.displayId, it.message)
    }
    return commits
}

return htmlBuild()

വിശദാംശങ്ങളിലേക്ക് കടക്കാതെ, ഈ കോഡ് മൈക്രോസർവീസ് നാമം (MICROSERVICE_NAME) ഇൻപുട്ടായി സ്വീകരിക്കുകയും ഒരു അഭ്യർത്ഥന അയയ്ക്കുകയും ചെയ്യുന്നു ബിറ്റ്ബാക്കെറ്റ് (രീതി ഗെറ്റ്കമ്മിറ്റ്സ് ഫോർ മൈക്രോസർവീസ്) അതിന്റെ API ഉപയോഗിച്ച്, നൽകിയിരിക്കുന്ന മൈക്രോസർവീസിനായി എല്ലാ കമ്മിറ്റുകളുടെയും ഐഡിയും കമ്മിറ്റ് സന്ദേശവും ലഭിക്കും.
നേരത്തെ സൂചിപ്പിച്ചതുപോലെ, ഈ കോഡ് പേജിൽ പ്രദർശിപ്പിക്കുന്ന html നൽകണം പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് നിർമ്മിക്കുക ജെൻകിൻസിൽ, അതിനാൽ ഞങ്ങൾ ബിറ്റ്ബക്കറ്റിൽ നിന്ന് ലഭിച്ച എല്ലാ മൂല്യങ്ങളും ഒരു ലിസ്റ്റിൽ പൊതിഞ്ഞ് അവ തിരഞ്ഞെടുക്കാൻ ചേർക്കുന്നു.

എല്ലാ ഘട്ടങ്ങളും പൂർത്തിയാക്കിയ ശേഷം, അത്തരമൊരു മനോഹരമായ പേജ് നമുക്ക് ലഭിക്കണം പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് നിർമ്മിക്കുക.

നിങ്ങൾ test1 microservice തിരഞ്ഞെടുത്തെങ്കിൽ:

നിങ്ങൾ test2 microservice തിരഞ്ഞെടുത്തെങ്കിൽ:

ഓരോ തവണയും url പകർത്തി ആവശ്യമായ കമ്മിറ്റ് ഐഡി തിരയുന്നതിനേക്കാൾ ഉപയോക്താക്കൾക്ക് ഈ രീതിയിൽ നിങ്ങളുടെ ടാസ്ക്കുമായി ഇടപഴകുന്നത് കൂടുതൽ സൗകര്യപ്രദമാകുമെന്ന് സമ്മതിക്കുക.

പി.എസ് ഈ ലേഖനം വളരെ ലളിതമായ ഒരു ഉദാഹരണം നൽകുന്നു, ഇത് ഈ രൂപത്തിൽ പ്രായോഗികമായി ഉപയോഗപ്രദമാകണമെന്നില്ല, കാരണം അസംബ്ലികൾക്ക് നിരവധി വ്യത്യസ്ത പാരാമീറ്ററുകൾ ഉണ്ട്, എന്നാൽ ഈ ലേഖനത്തിന്റെ ഉദ്ദേശ്യം ഉപകരണം എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കാണിക്കുക എന്നതായിരുന്നു, ഒരു പ്രവർത്തന പരിഹാരം നൽകലല്ല.

പി.എസ്.എസ് ഞാൻ നേരത്തെ എഴുതിയതുപോലെ, ഈ ലേഖനം ഉപയോഗപ്രദമാണെങ്കിൽ, അടുത്തത് അതിനെക്കുറിച്ചായിരിക്കും കോഡ് വഴി ജെങ്കിൻസ് ടാസ്ക്കുകളുടെ ഡൈനാമിക് കോൺഫിഗറേഷൻ.

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