Création de paramètres dynamiques dans Jenkins job, ou comment rendre votre tâche conviviale.

Bonjour, Habr!

Aujourd'hui, je voudrais partager l'une des façons de Active Choices Plugin réaliser une tâche dans Jenkins la manière la plus unifiée et compréhensible pour l'utilisateur.

Introduction

L'acronyme DevOps n'est plus quelque chose de nouveau pour la communauté IT. Pour beaucoup, l'expression « faire du DevOps » évoque un bouton magique, sur lequel une fois pressé, le code de l'application se transforme automatiquement en une application déployée et testée (tout est en réalité plus complexe, mais nous allons abstraire tous les processus).

Nous avons donc reçu une demande pour créer un tel bouton magique permettant aux administrateurs de déployer une application en un seul clic. Il existe différentes façons d'implémenter cette tâche : allant de l'écriture d'un bot pour l'un des messageries à la création d'une application dédiée. Néanmoins, l'objectif reste le même : rendre le lancement de la construction et le déploiement de l'application aussi transparent et pratique que possible.

Dans notre cas, nous allons utiliser Jenkins.

La tâche

Créer un job Jenkins convivial, qui lancera la construction et (ou) le déploiement d'un microservice sélectionné d'une version spécifique.

Données d'entrée

Nous avons plusieurs dépôts où le code source de différents microservices réside.

Définition des paramètres

Notre job doit recevoir les paramètres suivants :

1. URL du dépôt avec le code du microservice que nous souhaitons construire et déployer lors de l'exécution du job.
2. ID du commit à partir duquel la construction sera effectuée.

AS IS

La manière la plus simple de réaliser cette tâche consiste à créer deux paramètres de type String.

Dans ce cas, l'utilisateur devra saisir manuellement le chemin vers le dépôt et l'id du commit, ce qui, convenons-en, n'est pas très pratique.

AS TO BE

Essayons maintenant un autre type de paramètres pour en examiner tous les avantages.
Créons le premier paramètre de type Choice Parameter, le second — Active Choices Reactive Reference Parameter. Dans le champ Choices du paramètre de type Choice, ajoutons manuellement les noms des dépôts où se trouve le code de nos microservices.

Si cet article plaît à l'audience, dans le prochain article, je décrirai le processus de configuration des tâches dans Jenkins, en utilisant la description par code (Configuration as code), c'est-à-dire que nous n'aurons pas besoin d'entrer manuellement les noms des dépôts et de créer des paramètres, tout se fera automatiquement (notre code obtiendra la liste des dépôts à partir de SCM et créera un paramètre avec cette liste).

Les valeurs du deuxième paramètre seront remplies dynamiquement, en fonction de la valeur que prendra le premier paramètre (test1 ou test2), car chaque dépôt a sa propre liste de commits.

Paramètre de référence réactif Active Choices a les champs suivants à remplir :

1. Nom – nom du paramètre.
2. Script – code qui sera exécuté chaque fois que la valeur du paramètre dans le champ Paramètre référencé changera (dans notre cas, lorsque nous choisirons entre test1 et test2).
3. Description – brève description du paramètre.
4. Type de choix – type de l'objet retourné par le script (dans notre cas, nous retournerons du code html).
5. Paramètre référencé – nom du paramètre dont le changement de valeur exécutera le code de la section Script.

Passons directement à remplir le champ principal de ce paramètre. On nous propose deux types de mise en œuvre : utiliser Script Groovy ou Scriptler Script.
Nous choisissons le premier, car Scriptler est simplement un plugin qui enregistre les scripts que vous avez déjà écrits et vous permet de les utiliser dans d'autres tâches sans un nouveau copier-coller.

Code Groovy pour obtenir tous les commits du dépôt sélectionné :

AUTH = "login et mot de passe en Base64"                           
GIT_URL = "url de votre SCM (https://bitbucket.org/)"                       
PROJECT_NAME = "nom de la zone de projet où se trouvent les dépôts"

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

Sans entrer dans les détails, ce code prend en entrée le nom du microservice (MICROSERVICE_NAME), envoie une requête à Bitbucket (méthode getCommitsForMicroservice), en utilisant son API, et obtient l'id et le message de commit de tous les commits pour ce microservice.
Comme déjà mentionné, ce code doit retourner du html qui sera affiché sur la page Build with Parameters dans Jenkins, c'est pourquoi toutes les valeurs obtenues à partir de Bitbucket sont enveloppées dans une liste et ajoutées à select.

Après avoir effectué toutes les actions, nous devrions obtenir une jolie page comme celle-ci Build with Parameters.

Si le microservice test1 est sélectionné :

Si le microservice test2 est sélectionné :

Il est évident qu'il sera beaucoup plus pratique pour l'utilisateur d'interagir avec votre tâche de cette manière que de devoir chaque fois copier l'url et chercher le commit id nécessaire.

P.S. Dans cet article, un exemple très simplifié est présenté, qui n'a peut-être pas de valeur pratique tel quel, car les configurations ont beaucoup plus de paramètres différents, mais le but de cet article était de montrer le fonctionnement de l'outil, et non de fournir une solution opérationnelle.

P.S.S. Comme je l'ai déjà écrit précédemment, si cet article est utile, le suivant traitera de la configuration dynamique des tâches Jenkins via le code.

Source : habr.com