Al escribir las tuberías de jenkins, parece ser muy inconveniente comprometer cada nuevo cambio para ver si funciona.

¿Hay alguna manera de ejecutarlos localmente sin comprometer el código?

No puede ejecutar la secuencia de comandos de Pipeline localmente, ya que todo su propósito es la secuencia de comandos de Jenkins. (Esta es una de las razones por las que es mejor mantener su Jenkinsfilecódigo corto y limitado que realmente trata con las características de Jenkins; su lógica de compilación real debe manejarse con procesos externos o herramientas de compilación que invoque a través de una línea sho batpaso).

Si desea probar un cambio en Jenkinsfilevivo pero sin comprometerlo , use la función Replay agregada en 1.14

JENKINS-33925 rastrea lo deseado para un marco de prueba automatizado.

Tengo una solución que me funciona bien. Consiste en un jenkins local que se ejecuta en docker y un enlace web git para activar la canalización en el jenkins local en cada confirmación. Ya no necesita presionar a su repositorio github o bitbucket para probar la tubería.

Esto solo se ha probado en un entorno Linux.

Es bastante simple hacer que esto funcione, aunque esta instrucción es un poco larga. La mayoría de los pasos están ahí.

Esto es lo que necesitas

• Docker instalado y funcionando.Esto no es parte de esta instrucción.
• A Jenkins corriendo en el Docker localmente. Explicado cómo a continuación.
  • Los derechos adecuados (clave de acceso ssh) para que su usuario local de la ventana acoplable Jenkins pueda extraerlos de su repositorio git local. Explicado cómo a continuación.
  • Un proyecto de canalización de Jenkins que se extrae de su repositorio git local. Explicado a continuación.
  • Un usuario git en su Jenkins local con derechos mínimos. Explicado a continuación.
• Un proyecto git con un enlace web posterior a la confirmación que activa el proyecto de canalización. Explicado a continuación.

Así es como lo haces

Jenkins Docker

Cree un archivo llamado Dockerfile en lugar de su elección. Lo estoy colocando en /opt/docker/jenkins/Dockerfilellenarlo con esto:

FROM jenkins/jenkins:lts
USER root
RUN apt-get -y update && apt-get -y upgrade
# Your needed installations goes here
USER jenkins

Construye la imagen local_jenkins

Deberá hacerlo solo una vez o después de haber agregado algo al Dockerfile.

$ docker build -t local_jenkins /opt/docker/jenkins/

Iniciar y reiniciar local_jenkins

De vez en cuando desea iniciar y reiniciar jenkins fácilmente. Por ejemplo, después de reiniciar su máquina. Para esto hice un alias que puse .bash_aliasesen mi carpeta de inicio.

$ echo "alias localjenkinsrestart='docker stop jenkins;docker rm jenkins;docker run --name jenkins -i -d -p 8787:8080 -p 50000:50000 -v /opt/docker/jenkins/jenkins_home:/var/jenkins_home:rw local_jenkins'" >> ~/.bash_aliases
$ source .bash_aliases  # To make it work

Asegúrate que /opt/docker/jenkins/jenkins_home carpeta existe y de que tiene derechos de lectura y escritura para el usuario.

Para iniciar o reiniciar su jenkins simplemente escriba:

$ localjenkinsrestart

Todo lo que haga en su jenkins local se almacenará en la carpeta / opt / docker / jenkins / jenkins_home y se conservará entre reinicios.

Crea una clave de acceso ssh en tu docker jenkins

Esta es una parte muy importante para que esto funcione. Primero, iniciamos el contenedor docker y le creamos un bash shell:

$ localjenkinsrestart
$ docker exec -it jenkins /bin/bash

Ahora ha ingresado en el contenedor acoplable, esto se puede ver por algo como jenkins@e7b23bad10aa:/$ a su terminal. El hash después de la @ seguramente diferirá.

Crea la llave

jenkins@e7b23bad10aa:/$ ssh-keygen

Presione enter en todas las preguntas hasta que reciba el mensaje de vuelta

Copie la clave a su computadora. Desde el contenedor docker, su computadora es 172.17.0.1 en caso de que se pregunte.

jenkins@e7b23bad10aa:/$ ssh-copy-id [email protected]

usuario = su nombre de usuario y 172.17.0.1 es la dirección IP de su computadora desde el contenedor acoplable.

Tendrá que escribir su contraseña en este momento.

Ahora intentemos completar el ciclo enviando a su computadora desde el contenedor acoplable.

jenkins@e7b23bad10aa:/$ ssh [email protected]

Esta vez no debería necesitar ingresar su contraseña. Si lo hace, algo salió mal y debe intentarlo nuevamente.

Ahora estará en la carpeta de inicio de su computadora. Tratarls echar un vistazo.

No te detengas aquí ya que tenemos una cadena de proyectiles ssh de los que tenemos que salir.

$ exit
jenkins@e7b23bad10aa:/$ exit

¡Correcto! Ahora estamos de vuelta y listos para continuar.

Instala tu Jenkins

Encontrará su Jenkins local en su navegador en http: // localhost: 8787 .

La primera vez que apunte su navegador a su Jenkins local, recibirá un Asistente de instalación. Los valores predeterminados están bien, sin embargo, asegúrese de instalar el complemento de canalización durante la configuración.

Configura tus jenkins

Es muy importante que active la seguridad basada en matriz en http: // localhost: 8787 / configureSecurity y se otorgue todos los derechos agregándose a la matriz y marque todas las casillas. (Hay un ícono para marcar todas las casillas en el extremo derecho)

• Seleccione Jenkins’ own user databasecomo Reino de seguridad
• Seleccione Matrix-based securityen la sección Autorización
• Escriba su nombre de usuario en el campo User/group to add:y haga clic en el [ Add ]botón
• En la tabla anterior, su nombre de usuario debe aparecer con un icono de personas al lado. Si se cruza, escribió su nombre de usuario incorrectamente.
• Vaya al extremo derecho de la tabla y haga clic en el botón para marcar todos o marque manualmente todos los cuadros en su fila.
• Verifique que la casilla de verificación Prevent Cross Site Request Forgery exploitsno esté marcada. (Dado que solo se puede acceder a Jenkins desde su computadora, esto no es un gran problema)
• Haga clic [ Save ]y cierre sesión en Jenkins y vuelva a iniciarla solo para asegurarse de que funciona. Si no es así, debe comenzar desde el principio y vaciar la /opt/docker/jenkins/jenkins_homecarpeta antes de reiniciar

Agregar el usuario git

Necesitamos permitir que nuestro git hook inicie sesión en nuestro Jenkins local con derechos mínimos. Solo para ver y crear trabajos es suficiente. Por eso creamos un usuario llamadogit con contraseña login.

Dirija su navegador a http: // localhost: 8787 / securityRealm / addUser y agregue gitcomo nombre de usuario y logincontraseña. Haga clic en [ Create User ].

Agregue los derechos al usuario git

Vaya a la página http: // localhost: 8787 / configureSecurity en su navegador. Agregue el usuario git a la matriz:

• Escriba giten el campo User/group to add:y haga clic en[ Add ]

Ahora es el momento de marcar las casillas para obtener los derechos mínimos para el usuario git. Solo se necesitan estos:

• en general: leer
• trabajo: construir
• trabajo: descubrir
• trabajo: leer

Asegúrese de que la Prevent Cross Site Request Forgery exploitscasilla de verificación esté desmarcada y haga clic en[ Save ]

Crear el proyecto de tubería

Asumimos que tenemos el nombre de usuario usery nuestro proyecto habilitado para git con el Jenkinsfileque se llama projecty se encuentra en/home/user/projects/project

En su http: // localhost: 8787 Jenkins agregue un nuevo proyecto de canalización. Lo llamé hookpipeline como referencia.

• Haga clic New Itemen el menú de Jenkins
• Nombra el proyecto hookpipeline
• Haga clic en tubería
• Hacer clic [ OK ]
• Marque la casilla Poll SCMde verificación en la sección Build Triggers. Deje el horario vacío.
• En la sección de tubería:
  • Seleccione Pipeline script from SCM
  • en el Repository URLcampo ingrese[email protected]:projects/project/.git
  • en el Script Pathcampo ingreseJenkinsfile
• Guarde el proyecto de hookpipeline
• Construya el hookpipeline manualmente una vez, esto es necesario para que Poll SCM comience a funcionar.

Crea el gancho git

Vaya a la /home/user/projects/project/.git/hookscarpeta y cree un archivo llamado post-commitque contenga esto:

#!/bin/sh
BRANCHNAME=$(git rev-parse --abbrev-ref HEAD)
MASTERBRANCH='master'

curl -XPOST -u git:login http://localhost:8787/job/hookpipeline/build
echo "Build triggered successfully on branch: $BRANCHNAME"

Haga que este archivo sea ejecutable:

$ chmod +x /home/user/projects/project/.git/hooks/post-commit

Pruebe el gancho posterior a la confirmación:

$ /home/user/projects/project/.git/hooks/post-commit

Compruebe en Jenkins si su proyecto de hookpipeline se activó.

Finalmente, realice algún cambio arbitrario en su proyecto, agregue los cambios y realice una confirmación. Esto ahora activará la canalización en su Jenkins local.

¡Días felices!

TL; DR

• Marco de prueba de Jenkins Pipeline Unit
• Jenkinsfile Runner

Versión larga Las
pruebas de Jenkins Pipeline se vuelven cada vez más dolorosas. A diferencia del clásico enfoque de configuración de trabajo declarativo en el que el usuario estaba limitado a lo que la interfaz de usuario expuso, el nuevo Jenkins Pipeline es un lenguaje de programación completo para el proceso de construcción en el que mezcla la parte declarativa con su propio código. Como buenos desarrolladores, también queremos tener algunas pruebas unitarias para este tipo de código.

Hay tres pasos que debes seguir al desarrollar Jenkins Pipelines. El paso 1. debe cubrir el 80% de los casos de uso.

1. Haga todo lo posible en los scripts de compilación (por ejemplo, Maven, Gradle, Gulp, etc.). Luego, en los scripts de su canalización, simplemente llama a las tareas de compilación en el orden correcto. La canalización de compilación solo organiza y ejecuta las tareas de compilación, pero no tiene ninguna lógica importante que necesite una prueba especial.
2. Si la regla anterior no se puede aplicar completamente, pase a las bibliotecas de Pipeline Shared donde puede desarrollar y probar la lógica personalizada por su cuenta e integrarlas en la tubería.
3. Si todo lo anterior falla, puede probar una de esas bibliotecas que surgieron recientemente (marzo-2017). Marco de prueba de Jenkins Pipeline Unit o pipelineUnit (ejemplos). Desde 2018 también existe Jenkinsfile Runner , un paquete para ejecutar tuberías de Jenkins desde una herramienta de línea de comandos.

Ejemplos

El repositorio pipelineUnit GitHub contiene algunos ejemplos de Spock sobre cómo usar el marco de prueba de Jenkins Pipeline Unit

Jenkins tiene una función de 'Reproducción', que le permite reproducir rápidamente un trabajo sin actualizar las fuentes:

En el momento de escribir (finales de julio de 2017) con el complemento Blue Ocean , puede verificar la sintaxis de una tubería declarativa directamente en el editor visual de tuberías . El editor funciona desde la interfaz de usuario de Blue Ocean cuando hace clic en "configurar" solo para proyectos de github (este es un problema conocido y están trabajando para que funcione también en git, etc.).

Pero, como se explica en esta pregunta , puede abrir el editor navegando para:

[Jenkins URL]/blue/organizations/jenkins/pipeline-editor/

Luego haga clic en el medio de la página y presione Ctrl+S, esto abrirá un área de texto donde puede pegar un script declarativo de canalización. Cuando hace clic en Actualizar , si hay un error de sintaxis, el editor le informará dónde está el error de sintaxis. Como en esta captura de pantalla:

Si no hay un error de sintaxis, el área de texto se cerrará y la página visualizará su canalización. No se preocupe, no guardará nada (si se trata de un proyecto github, se cometería el cambio de Jenkinsfile).

Soy nuevo en Jenkins y esto es bastante útil, sin esto tuve que cometer un archivo Jenkins muchas veces, hasta que funcione (¡muy molesto!). Espero que esto ayude. Salud.

Un poco tarde para la fiesta, pero por eso escribí jenny, una pequeña reimplementación de algunos pasos básicos de Jenkinsfile. ( https://github.com/bmustiata/jenny )

Por lo que sé, este plugin de canalización es el "motor" de la nueva mecánica de Jenkinsfile, así que estoy bastante seguro de que podría usar esto para probar localmente sus scripts.

No estoy seguro de si se necesitan pasos adicionales al copiarlo en un archivo Jenkins, sin embargo, la sintaxis, etc., debe ser exactamente la misma.

Editar: se encontró la referencia en el "motor", verifique esta descripción de la característica, último párrafo, primera entrada.

En mi configuración de desarrollo, a falta de un editor Groovy adecuado, una gran cantidad de problemas de Jenkinsfile se origina en simples errores de sintaxis . Para abordar este problema, puede validar el archivo Jenkins en su instancia de Jenkins (ejecutándose en $JENKINS_HTTP_URL):

curl -X POST -H $(curl '$JENKINS_HTTP_URL/crumbIssuer/api/xml?xpath=concat(//crumbRequestField,":",//crumb)') -F "jenkinsfile=<Jenkinsfile" $JENKINS_HTTP_URL/pipeline-model-converter/validate

El comando anterior es una versión ligeramente modificada de https://github.com/jenkinsci/pipeline-model-definition-plugin/wiki/Validating-(or-linting)-a-Declarative-Jenkinsfile-from-the-command-line

Además de la función de reproducción que otros ya mencionaron (¡lo mismo ocurre con su utilidad!), También encontré que lo siguiente es útil:

1. Cree un trabajo de prueba de Pipeline donde pueda escribir el código de Pipeline o apuntar a su repositorio / rama de un Jenkinsfile para probar rápidamente algo. Para realizar pruebas más precisas, use una tubería de múltiples ramas que apunte a su propia bifurcación, donde puede realizar cambios y comprometerse rápidamente sin afectar la producción. Cosas como BRANCH_NAME env solo están disponibles en Multibranch.
2. Dado que Jenkinsfile es un código Groovy, simplemente invoque con "groovy Jenkinsfile" para validar la sintaxis básica.

Ponga su clave SSH en su perfil de Jenkins, luego use el linter declarativo de la siguiente manera:

ssh jenkins.hostname.here declarative-linter < Jenkinsfile

Esto hará un análisis estático en su Jenkinsfile. En el editor que elija, defina un método abreviado de teclado que ejecute ese comando automáticamente. En Visual Studio Code, que es lo que uso, vaya a Tareas> Configurar tareas, luego use el siguiente JSON para crear un comando Validar Jenkinsfile :

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Validate Jenkinsfile",
      "type": "shell",
      "command": "ssh jenkins.hostname declarative-linter < ${file}"
    }
  ]
}

Estoy usando Replay Future para actualizar y ejecutar rápidamente.

Con algunas limitaciones y para las tuberías con guiones, uso esta solución:

1. Trabajo de canalización con un script maravilloso en línea:

node('master') {
    stage('Run!') {
                def script = load('...you job file...')
    }
}

2. Jenkinsfile para pruebas tiene la misma estructura que para lesfurets:

def execute() {
 ... main job code here ...
}
execute()