web-dev-qa-db-fra.com

Configuration de la matrice avec les pipelines Jenkins

Le plugin Jenkins Pipeline (alias Workflow) peut être étendu avec d'autres plugins Multibranch pour créer des branches et extraire des requêtes automatiquement.

Quelle serait la meilleure façon d'exécuter plusieurs configurations? Par exemple, la construction avec Java 7 et Java 8. Ceci est souvent appelé configuration de matrice (en raison des multiples combinaisons telles que la version du langage, la version du framework,. ..) ou créer des variantes.

J'ai essayé:

  • les exécuter en série en tant qu'étapes stage distinctes. Bon, mais prend plus de temps que nécessaire.
  • les exécutant à l'intérieur d'une étape parallel, avec ou sans nodes alloués à l'intérieur. Fonctionne mais je ne peux pas utiliser l'étape stage à l'intérieur du parallèle pour les limitations connues sur la façon dont il serait visualisé.

Existe-t-il un moyen recommandé de procéder?

jenkinsjenkins-pipelinejenkins-blueocean
26
giorgiosironi

Il semble qu'il y ait du soulagement au moins avec le BlueOcean UI . Voici ce que j'ai (le tk-* les nœuds sont les étapes parallèles):

enter image description here

1
StephenKing

TLDR: Jenkins.io veut que vous utilisiez nœuds pour chaque build.

Jenkins.io: Dans les contextes de codage de pipeline, un "nœud" est une étape qui fait deux choses, généralement en demandant l'aide des exécuteurs disponibles sur les agents:

  1. Planifie l'exécution des étapes qu'il contient en les ajoutant à la file d'attente de génération Jenkins (de sorte que dès qu'un emplacement d'exécuteur est libre sur un nœud, les étapes appropriées s'exécutent)

  2. Il est recommandé d'effectuer tout le travail matériel, comme la création ou l'exécution de scripts Shell, au sein des nœuds, car les blocs de nœuds d'une étape indiquent à Jenkins que les étapes qu'ils contiennent sont suffisamment gourmandes en ressources pour être planifié, demander de l'aide au pool d'agents et verrouiller un espace de travail aussi longtemps qu'ils en ont besoin.

Vanilla Jenkins Node des blocs d'une étape ressembleraient à:

stage 'build' {
    node('Java7-build'){ ... }
    node('Java8-build'){ ... }
}

Etendant encore cette notion, Cloudbees écrit sur parallélisme et builds distribués avec Jenkins . Le flux de travail Cloudbees pour vous pourrait ressembler à:

stage 'build' {
    parallel 'Java7-build':{
      node('mvn-Java7'){ ... }
    }, 'Java8-build':{
      node('mvn-Java8'){ ... }
    }
}

Vos exigences de visualisation des différentes versions du pipeline pourraient être satisfaites avec l'un ou l'autre flux de travail, mais je fais confiance à la documentation Jenkins pour les meilleures pratiques.

ÉDITER

Pour aborder la visualisation @ Stephen aimerait voir, Il a raison - cela ne fonctionne pas! Le problème a été soulevé avec Jenkins et est documenté ici , la résolution d'impliquer l'utilisation de "blocs étiquetés" est toujours en cours :-(

Q: Existe-t-il une documentation permettant aux utilisateurs du pipeline de ne pas placer d'étapes à l'intérieur d'étapes parallèles?

R: Non, et cela est considéré comme une utilisation incorrecte si cela est fait; les étapes ne sont valables qu'en tant que constructions de niveau supérieur dans le pipeline, c'est pourquoi la notion de blocs étiquetés en tant que construction distincte est devenue ... Et par cela, je veux dire supprimer les étapes des étapes parallèles dans mon pipeline.

Si vous essayez d'utiliser une étape dans un travail parallèle, vous allez avoir un mauvais moment.

ERROR: The ‘stage’ step must not be used inside a ‘parallel’ block.
15
Stefan Crain

Afin de tester chaque commit sur plusieurs plateformes, j'ai utilisé ce squelette de base Jenkinsfile:

def test_platform(label, with_stages = false)
{
    node(label)
    {
        // Checkout
        if (with_stages) stage label + ' Checkout'
        ...

        // Build
        if (with_stages) stage label + ' Build'
        ...

        // Tests
        if (with_stages) stage label + ' Tests'
        ...
    }
}

/*
parallel ( failFast: false,
    Windows: { test_platform("Windows") },
    Linux:   { test_platform("Linux")   },
    Mac:     { test_platform("Mac")     },
)
*/

test_platform("Windows", true)
test_platform("Mac",     true)
test_platform("Linux",   true)

Avec cela, il est relativement facile de passer d'une exécution séquentielle à une exécution parallèle, chacun d'eux ayant ses avantages et ses inconvénients:

  • L'exécution parallèle s'exécute beaucoup plus rapidement, mais elle ne contient pas l'étiquetage des étapes
  • L'exécution séquentielle est beaucoup plus lente, mais vous obtenez un rapport détaillé grâce aux étapes, intitulées "Windows Checkout", "Windows Build", "Windows Tests", "Mac Checkout", etc.)

J'utilise l'exécution séquentielle pour le moment, jusqu'à ce que je trouve une meilleure solution.

2
Jordi Vilalta Prat

Comme indiqué par @StephenKing, Blue Ocean montrera mieux les branches parallèles que la vue actuelle de la scène. Une prochaine version planifiée de la vue de la scène pourra montrer toutes les branches, mais elle n'indiquera visuellement aucune structure d'imbrication (ressemblerait à si vous exécutiez les configurations en série).

Dans tous les cas, le problème le plus profond est que vous n'obtiendrez essentiellement qu'un état de réussite/échec pour la génération globale, en attendant une résolution de JENKINS-27395 et des demandes associées.

2
Jesse Glick