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

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

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

ആമുഖം

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

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

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

ലക്ഷ്യം

ഒരു പ്രത്യേക പതിപ്പിന്റെ തിരഞ്ഞെടുത്ത മൈക്രോസർവീസിന്റെ ബിൽഡ് കൂടാതെ/അല്ലെങ്കിൽ വിന്യാസം ആരംഭിക്കുന്ന ഒരു സൗകര്യപ്രദമായ ജെങ്കിൻസ് ജോലി സൃഷ്ടിക്കുക.

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

വിവിധ മൈക്രോസർവീസുകൾക്കായുള്ള സോഴ്‌സ് കോഡ് അടങ്ങിയ നിരവധി ശേഖരണങ്ങൾ ഞങ്ങളുടെ പക്കലുണ്ട്.

പാരാമീറ്ററുകളുടെ നിർവചനം

നമ്മുടെ ജോലിയുടെ ഇൻപുട്ടിൽ ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ നൽകണം:

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

അതു പൊലെ

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

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

ആയിരിക്കേണ്ടതുപോലെ

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

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

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

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

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

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

തിരഞ്ഞെടുത്ത ഒരു റിപ്പോസിറ്ററിയിൽ നിന്ന് എല്ലാ കമ്മിറ്റുകളും ലഭിക്കുന്നതിനുള്ള ഗ്രൂവി കോഡ്:

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 മൈക്രോസർവീസ് തിരഞ്ഞെടുത്താൽ:

നിങ്ങൾ test2 മൈക്രോസർവീസ് തിരഞ്ഞെടുത്താൽ:

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

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

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

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