example - Jenkins Build Pipeline-Reinicio en el escenario

jenkinsfile

Question

Tengo el siguiente pipeline de compilación configurado como un trabajo:

Stage 1 - verify all dependencies exist
Stage 2 - build the new jar
Stage 3 - Run integration tests
Stage 4 - Deploy to staging environment (manual step)
Stage 5 - Deploy to production environment (manual step)

Estoy buscando una manera de iniciar la construcción de la tubería desde una etapa particular en caso de una falla transitoria. Por ejemplo, digamos que hubo un problema de red cuando el usuario hizo clic para implementar en producción. No creo que tenga sentido comenzar la tubería desde la etapa 1 ... Me gustaría intentar ese paso nuevamente y continuar desde allí en la tubería. No veo ninguna funcionalidad como esta en el complemento Build Pipeline.

¡¡Gracias!!

Answer 1

Aquí hay otro boceto para ejecutar las etapas condicionalmente sin romper el historial del complemento de la vista de escenario.

Como dicen ellos :

Etapas dinámicas: en general, si desea visualizar etapas cambiantes dinámicamente, condicione la ejecución del contenido de la etapa, no condicional para incluir la etapa.

Esto es lo que he encontrado hasta ahora. Parece funcionar principalmente: (Solo ignora los otros pasos ficticios)

Definimos una pequeña función de ayuda conditionalStage Etapa que envuelve perfectamente la comprobación del nombre de la etapa desde el parámetro de Trabajo Jenkins de JP_STAGE .

Observe cómo conditionalStage primero abre el stage y luego comprueba stageIsActive dentro del escenario, simplemente saltando todos los pasos. De esta manera, el complemento de vista de escenario ve todas las etapas y no se desordena, pero los pasos de las etapas aún se omiten.

def stageSelect = JP_STAGE.toLowerCase()

// test if stage or any of sub-stages is active
def stageIsActive(theStage, theStages) { 
    // echo "pass: $theStages"
    // ARGL: https://issues.jenkins-ci.org/browse/JENKINS-26481
    // def lcStages = theStages.collect {it.toLowerCase()}
    def lcStages = []
    for (def s : theStages) { lcStages += s.toLowerCase() }
    def lcAllStages = lcStages + [''all'']
    // echo "check: $lcAllStages"
    // echo JP_STAGE.toLowerCase()
    if (JP_STAGE.toLowerCase() in lcAllStages) {
        echo "Run: Stage ''$theStage'' is active through ''$JP_STAGE''."
        return true
    } else {
        echo "Skip: Stage ''$theStage'' is NOT active through ''$JP_STAGE''."
        return false
    }
}

// 1st element should be the stage, optionally followed by all sub-stages
def conditionalStage(names, stageBody) {
  stage(names[0]) { if (stageIsActive(names[0], names)) {
    stageBody()
  }}  
}

timestamps {
// --S--

conditionalStage([''Intro'']) { 
    echo ''Outside Node''

    build job: ''FreeX'', wait: true
    sleep 3
}

// --S--
conditionalStage([''AtNode'', ''Hello'', ''Done'']) {
    node {
        // Cloudbees Enterprise Only: checkpoint ''Now''
        conditionalStage([''Hello'']) {
            echo ''Hello World @ Node''
            sleep 4
        }
        conditionalStage([''Done'']) {
            dir(''C:/local'') {
                echo pwd()
            }
        }
    }
}

}//timestamps

Answer 2

Creo que el checkpoint es lo que estás buscando. Desafortunadamente, solo está disponible en la suite CloudBees Jenkins Enterprise, no en la versión gratuita.

Esperemos que llegue a la versión de código abierto ya que parece ser un caso de uso muy común.

Answer 3

Lo que podrías hacer es poner los pasos individuales en guiones geniales. Luego, puede hacer un trabajo "ejecutar todos" que carga todos los scripts en el orden correcto, y trabajos individuales para los diferentes pasos.

Aunque esta es una forma en la que debería funcionar, no creo que esta sea la solución ideal, ya que significa que debe tener cuidado de cómo los diferentes pasos intercambian información, de modo que los pasos se puedan ejecutar de manera independiente.

Una solución integrada sería mucho mejor.

Answer 4

Mientras tanto, todas las demás respuestas están obsoletas, ya que Jenkins proporciona una solución integrada que le permite reiniciar un trabajo desde cualquier etapa: jenkins.io/doc/book/pipeline/running-pipelines

Answer 5

Puede envolver su código en un paso de retry :

stage "Deployment"
retry(3) {
  sh "deploy.."
}

EDITAR: Esto podría ayudar en la versión gratuita de Jenkins. Usuarios de CloudBees Enterprise , por favor vea la respuesta de @tarantoga .

Answer 6

Un tema un poco viejo, pero dado que Jenkins todavía (!) No es compatible con esto, estoy enviando otra solución para implementaciones de canalización con script. Se basa en la lista de etapas de construcción de forma dinámica al ejecutar tuberías.

1. paso - etapas definición enum

enum Steps {
  PREPARE(0, "prepare"), 
    BUILD(1, "build"), 
    ANALYSE(2, "analyse"), 
    CHECKQG(3, "checkQG"), 
    PROVISION(4, "provision"), 
    DEPLOY(5, "deploy"), 
    ACTIVATE(6, "activate"), 
    VERIFY(7, "verify"), 
    CLEANUP(8, "cleanup")

  Steps(int id, String name) {
      this.id = id
          this.name = name
  }

  private final int id
    private final String name

  int getId() {
      id
  }

      String getName() {
      name
  }

    public static Steps getByName(String name) {
        println "getting by name " + name
        for(Steps step : Steps.values()) {
          if(step.name.equalsIgnoreCase(name)) { 
              return step 
          }
        }
        throw new IllegalArgumentException()
    }
}

2. Método de creación de la lista de pasos finales.

  def prepareStages(def startPoint){
        println "preparing build steps starting from " + startPoint
        Set steps = new LinkedHashSet()
        steps.add(Steps.PREPARE)
        steps.add(Steps.BUILD)
        steps.add(Steps.ANALYSE)
        steps.add(Steps.CHECKQG)
        steps.add(Steps.PROVISION)
        steps.add(Steps.DEPLOY)
        steps.add(Steps.ACTIVATE)
        steps.add(Steps.VERIFY)
        steps.add(Steps.CLEANUP)
        List finalSteps = new ArrayList()
        steps.each{
            step ->
                if (step.id >= startPoint.id) {
                    finalSteps.add(step)
                }
        }
        return finalSteps
    }

3. y tu puedes usarlo asi

def stage = prepareStages (Steps.getByName ("$ {startStage}"))

node {
    try {
        //pipelineTriggers([pollSCM(''${settings.scmPoolInterval}'')])  //this can be used in future to get rid build hooks 

        sh "echo building " + buildVersionNumber(${settings.isTagDriven})
        tool name: ''mvn_339_jenkins'', type: ''maven''

        script {             
            println "running: " + stages
        }

        stage(''Prepare'') {
            if (stages.contains(Steps.PREPARE)) {
                script { currentStage = ''Prepare'' }
               //.....
            }
        } //...

el "startStage" es un parámetro de compilación definido de la siguiente manera

parámetros {choiceParam (''startStage'', [''prepare'', ''build'', ''analyse'', ''checkQG'', ''provision'', ''deploy'', ''active'', ''Verify'', ''cleanup''], ''Pick up the etapa en la que quieres comenzar desde '')}

Esto me permite retomar la etapa desde la que quiero comenzar (la etapa de preparación está configurada de forma predeterminada)

Answer 7

Una mejor solución es una solución similar a lo que sugerí en esta pregunta :

Escriba un script de canalización que tenga "si" -guardias alrededor de las etapas individuales, como esto:

stage "s1"
if (theStage in ["s1"]) {
    sleep 2
}

stage "s2"
if (theStage in ["s1", "s2"]) {
    sleep 2
}

stage "s3"
if (theStage in ["s1", "s2", "s3"]) {
    sleep 2
}

Luego, puede hacer un trabajo "principal" que use este script y ejecute todas las etapas al mismo tiempo configurando el parámetro "theStage" en "s1". Este trabajo recopilará las estadísticas cuando todas las etapas se ejecuten a la vez y le dará tiempos de estimación útiles.

Además, puede realizar un trabajo de "ejecución parcial" que use este script y que esté parametrizado con la etapa con la que desea comenzar. Sin embargo, la estimación no será muy útil.