Plugin de canalización

Puede usar el complemento de canalización (anteriormente workflow-plugin).

Viene con muchos ejemplos, y usted puede seguir este tutorial.

Por ejemplo

// build
stage 'build'
...

// deploy
stage 'deploy'
...

// run tests in parallel
stage 'test'
parallel 'functional': {
  ...
}, 'performance': {
  ...
}

// promote artifacts
stage 'promote'
...

Plugin de flujo de compilación

También puedes usar el plugin Build Flow. Es simplemente impresionante - pero está en desuso (desarrollo congelado).

Configurar los trabajos

Crear puestos de trabajo por:

• construir
• desplegar
• pruebas de rendimiento
• pruebas funcionales
• promoción

Configurando el upstream

1. En el upstream (aquí build) crear un artefacto único, por ejemplo:

   echo ${BUILD_TAG} > build.tag
   

2. Archive el artefacto build.tag.

3. registrar huellas dactilares para rastrear el uso del archivo; si cualquier trabajo copia el mismo archivo build.tag y registra huellas dactilares, podrá rastrear el padre.
4. Configure para ser promovido cuando el trabajo promotion se realice correctamente.

Configurando los trabajos descendentes

1. Utilizo 2 parámetros PARENT_JOB_NAME y PARENT_BUILD_NUMBER

2. Copie los artefactos del trabajo upstream build usando el complemento Copy Artifact

   • Nombre del proyecto = ${PARENT_JOB_NAME}
   • Que build = ${PARENT_BUILD_NUMBER}
   • Artefactos a copiar = build.tag

3. Grabar huellas dactilares; eso es crucial.

Configurar el trabajo de promoción descendente

Haga lo mismo que lo anterior, para establecer una relación aguas arriba-aguas abajo. No necesita ningún paso de construcción. Puedes realizar acciones adicionales post-build como "hey QA, es tu turno".

Crear un trabajo de flujo de compilación

// start with the build
parent = build("build")
parent_job_name = parent.environment["JOB_NAME"]
parent_build_number = parent.environment["BUILD_NUMBER"]

// then deploy
build("deploy")

// then your qualifying tests
parallel (
    { build("functional tests",
          PARENT_BUILD_NUMBER: parent_build_number,
          PARENT_JOB_NAME: parent_job_name) },
    { build("performance tests",
          PARENT_BUILD_NUMBER: parent_build_number,
          PARENT_JOB_NAME: parent_job_name) }
)

// if nothing failed till now...
build("promotion",
    PARENT_BUILD_NUMBER: parent_build_number,
    PARENT_JOB_NAME: parent_job_name)

// knock yourself out...
build("more expensive QA tests",
    PARENT_BUILD_NUMBER: parent_build_number,
    PARENT_JOB_NAME: parent_job_name)

Buena suerte.

Jenkins recientemente anunció soporte de primera clase para workflow.

El complemento Multijob funciona muy bien para ese escenario. También es útil si desea que un solo trabajo "padre" inicie varios trabajos "hijos" pero aún así pueda ejecutar cada uno de los hijos manualmente, por sí mismos. Esto funciona mediante la creación de "fases", a la que se añade 1 a n trabajos. La compilación solo continúa cuando se realiza toda la fase, por lo que si una fase como varios trabajos, todos deben completarse antes de que se ejecuten el resto. Naturalmente, es configurable si la construcción continúa si hay un fallo dentro de la fase.

Las respuestas de jason & dnozay son suficientemente buenas. Pero en caso de que alguien esté buscando una manera fácil, simplemente use JobFanIn plugin .

Creo que el Complemento de Flujo de trabajo ahora se llama el Complemento de Canalización y es la solución preferida (actual) a la pregunta original, inspirada en el Complemento Build Flow. También hay un Tutorial de Introducción en GitHub.