🥇Skapa dynamiska parametrar i ett Jenkins-jobb, eller hur du gör din uppgift användarvänlig

God dag, Habr!

Idag skulle jag vilja dela med mig av ett av sätten att använda Aktiva val plugin göra uppgiften i Jenkins den mest enhetliga och användarvänliga.

Inledning

En sådan förkortning som DevOps är inte längre något nytt för IT-gemenskapen. För många människor är frasen "gör DevOps" förknippad med någon form av magisk knapp, när den klickas förvandlas applikationskoden automatiskt till en utplacerad och testad applikation (allt är faktiskt mer komplicerat, men vi abstraherar från alla processer).

Så vi fick en order om att göra en sådan magisk knapp så att administratörer kunde distribuera programmet med ett klick. Det finns olika typer av implementering av denna uppgift: från att skriva en bot för någon av instant messengers till att utveckla en separat applikation. Ändå har allt detta samma mål - att göra starten av byggandet och distributionen av applikationen så transparent och bekväm som möjligt.

I vårt fall kommer vi att använda Jenkins.

Uppgift

Skapa ett bekvämt Jenkins-jobb som kommer att starta byggandet och (eller) distributionen av den valda mikrotjänsten av en viss version.

Indata

Vi har flera arkiv som innehåller källkoden för olika mikrotjänster.

Definiera parametrar

Följande parametrar bör tas emot som input till vårt jobb:

URL:en till arkivet med mikrotjänstkoden som vi vill bygga och distribuera när vi kör jobbet.
ID för commit från vilken byggnaden kommer att ske.

SOM DEN ÄR

Det enklaste sättet att utföra denna uppgift är att skapa två parametrar av typen String.

I det här fallet måste användaren manuellt ange sökvägen till förvaret och commit-id, vilket, du ser, inte är helt bekvämt.

SOM SKA VARA

Låt oss nu prova en annan typ av parametrar för att överväga alla dess fördelar.
Låt oss skapa den första parametern med typen Valparameter, den andra - Active Choices Reactive Reference Parameter. I parametern med typen Choice kommer vi manuellt att lägga till i fältet Choices namnen på arkiven där koden för våra mikrotjänster lagras.

Om publiken gillar den här artikeln kommer jag i nästa artikel att beskriva processen för att konfigurera uppgifter i Jenkins, med hjälp av en beskrivning genom kod (Konfiguration som kod), d.v.s. vi behöver inte manuellt ange arkivnamn och skapa parametrar, allt kommer att ske automatiskt (vår kod kommer att få en lista över arkiv från SCM och skapa en parameter med denna lista).

Värdena för den andra parametern kommer att fyllas i dynamiskt, beroende på vilket värde den första parametern tar (test1 eller test2), eftersom varje repository har sin egen lista med commits.

Active Choices Reactive Reference Parameter har följande fält att fylla i:

Namn – parameternamn.
Script – kod som kommer att exekveras varje gång värdet på parametern från fältet Refererad parameter ändras (i vårt fall när vi väljer mellan test1 och test2).
Beskrivning – kort beskrivning av parametern.
Valtyp – typen av objekt som returneras av skriptet (i vårt fall returnerar vi html-kod).
Refererad parameter – namnet på parametern, när värdet på vars värde ändras kommer koden från Script-sektionen att exekveras.

Låt oss fortsätta direkt till att fylla i det viktigaste fältet i denna parameter. Vi erbjuds två typer av implementering att välja mellan: att använda Groovy manus eller Scriptler Script.
Vi väljer den första, eftersom Scriptler bara är en plugin som sparar skript du tidigare skrivit och låter dig använda dem i andra uppgifter utan att kopiera och klistra igen.

Groovy kod för att få alla commits från det valda arkivet:

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()

Utan att gå in på detaljer får den här koden mikrotjänstens namn (MICROSERVICE_NAME) som indata och skickar en begäran till Bit hink (metod getCommitsForMicroservice) använder sitt API och får id och commit-meddelandet för alla commits för en given mikrotjänst.
Som nämnts tidigare bör denna kod returnera html som kommer att visas på sidan Bygg med parametrar i Jenkins, så vi lindar alla mottagna värden från Bitbucket i en lista och lägger till dem för att välja.

Efter att ha slutfört alla steg borde vi få en så vacker sida Bygg med parametrar.

Om du valde test1 mikrotjänst:

Om du valde test2 mikrotjänst:

Håller med om att det kommer att vara mycket bekvämare för användaren att interagera med din uppgift på det här sättet än att kopiera webbadressen varje gång och leta efter det nödvändiga commit-id:t.

PS Den här artikeln ger ett mycket förenklat exempel, som kanske inte är praktiskt användbar i denna form, eftersom sammansättningar har många fler olika parametrar, men syftet med denna artikel var att visa hur verktyget fungerar, inte att ge en fungerande lösning.

PSS Som jag skrev tidigare, om den här artikeln är användbar, kommer nästa att handla om dynamisk konfiguration av Jenkins uppgifter via kod.

Källa: will.com

Skapa dynamiska parametrar i ett Jenkins-jobb, eller hur du gör din uppgift användarvänlig