Quando si scrivono pipeline jenkins sembra molto scomodo impegnare ogni nuova modifica per vedere se funziona.

C'è un modo per eseguirli localmente senza impegnare il codice?

Non è possibile eseguire lo script Pipeline localmente, poiché il suo scopo è lo script Jenkins. (Questo è uno dei motivi per cui è meglio mantenere il Jenkinsfilecodice breve e limitato al codice che tratta effettivamente le funzionalità di Jenkins; la tua logica di compilazione effettiva dovrebbe essere gestita con processi esterni o strumenti di compilazione che invochi tramite una riga shobat passaggio.)

Se vuoi testare una modifica per Jenkinsfilevivere ma senza impegnarla , usa la funzione Replay aggiunta in 1.14

JENKINS-33925 tiene traccia del desiderato per un framework di test automatizzato.

Ho una soluzione che funziona bene per me. Consiste in un jenkins locale in esecuzione nella finestra mobile e in un hook git web per attivare la pipeline nei jenkins locali ad ogni commit. Non è più necessario eseguire il push nel repository github o bitbucket per testare la pipeline.

Questo è stato testato solo in un ambiente Linux.

È abbastanza semplice farlo funzionare anche se questa istruzione è un po 'lunga. La maggior parte dei passaggi ci sono.

questo è quello di cui hai bisogno

• Docker installato e funzionante. Questo non fa parte di questa istruzione.
• Un Jenkins in esecuzione nella finestra mobile localmente. Spiegato come di seguito.
  • I diritti corretti (chiave di accesso ssh) per l'utente docker Jenkins locale da estrarre dal repository git locale. Spiegato come di seguito.
  • Un progetto di pipeline Jenkins che estrae dal tuo repository git locale. Spiegato di seguito.
  • Un utente git nel tuo Jenkins locale con diritti minimi. Spiegato di seguito.
• Un progetto git con un hook web post-commit che attiva il progetto pipeline. Spiegato di seguito.

Questo è come lo fai

Jenkins Docker

Crea un file chiamato Dockerfile al posto della tua scelta. Lo sto inserendo e /opt/docker/jenkins/Dockerfileriempilo con questo:

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

Costruisci l'immagine local_jenkins

Questo dovrai farlo solo una volta o dopo aver aggiunto qualcosa al Dockerfile.

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

Avvia e riavvia local_jenkins

Di tanto in tanto vuoi avviare e riavviare jenkins facilmente. Ad esempio dopo un riavvio del computer. Per questo ho creato un alias che ho inserito .bash_aliasesnella mia cartella home.

$ 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

Assicurati che la /opt/docker/jenkins/jenkins_homecartella esista e che tu abbia i diritti di lettura e scrittura dell'utente.

Per avviare o riavviare jenkins basta digitare:

$ localjenkinsrestart

Tutto ciò che fai nei tuoi jenkins locali verrà archiviato nella cartella / opt / docker / jenkins / jenkins_home e conservato tra i riavvii.

Crea una chiave di accesso ssh nella finestra mobile jenkins

Questa è una parte molto importante perché funzioni. Per prima cosa iniziamo il container docker e creiamo una shell bash su di esso:

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

Ora sei entrato nel contenitore della finestra mobile, come puoi vedere da qualcosa del genere jenkins@e7b23bad10aa:/$ nel tuo terminale. L'hash dopo @ sarà sicuramente diverso.

Crea la chiave

jenkins@e7b23bad10aa:/$ ssh-keygen

Premi Invio su tutte le domande fino a quando non ricevi nuovamente il messaggio

Copia la chiave sul tuo computer. Dal contenitore docker il tuo computer è 172.17.0.1 dovresti chiederti.

jenkins@e7b23bad10aa:/$ ssh-copy-id user@172.17.0.1

user = il tuo nome utente e 172.17.0.1 è l'indirizzo IP del tuo computer all'interno del contenitore della finestra mobile.

A questo punto dovrai digitare la password.

Ora proviamo a completare il ciclo inviando un messaggio al computer dall'interno della finestra mobile.

jenkins@e7b23bad10aa:/$ ssh user@172.17.0.1

Questa volta non dovresti aver bisogno di inserire la tua password. Se lo fai, qualcosa è andato storto e devi riprovare.

Ora sarai nella cartella home del tuo computer. Prova lsa dare un'occhiata.

Non fermarti qui perché abbiamo una catena di shell ssh da cui dobbiamo uscire.

$ exit
jenkins@e7b23bad10aa:/$ exit

Destra! Ora siamo tornati e pronti per continuare.

Installa il tuo Jenkins

Troverai il tuo Jenkins locale nel tuo browser all'indirizzo http: // localhost: 8787 .

La prima volta che punti il ​​tuo browser verso il tuo Jenkins locale sarai accolto con una procedura guidata di installazione. I valori predefiniti vanno bene, ma assicurati di installare il plug-in della pipeline durante l'installazione.

Imposta i tuoi jenkins

È molto importante attivare la sicurezza basata su matrice su http: // localhost: 8787 / configureSecurity e concederti tutti i diritti aggiungendoti alla matrice e spuntando tutte le caselle. (C'è un'icona di tutte le caselle all'estrema destra)

• Selezionare Jenkins’ own user database come reame di sicurezza
• Selezionare Matrix-based security nella sezione Autorizzazione
• Scrivi il tuo nome utente nel campo User/group to add:e fai clic su[ Add ] pulsante
• Nella tabella sopra il tuo nome utente dovrebbe apparire con un'icona di persone accanto ad esso. Se viene attraversato, hai digitato il nome utente in modo errato.
• Vai all'estrema destra della tabella e fai clic sul pulsante di spunta tutto o seleziona manualmente tutte le caselle della riga.
• Verifica che la casella di controllo Prevent Cross Site Request Forgery exploitssia deselezionata. (Dal momento che questo Jenkins è raggiungibile solo dal tuo computer, questo non è un grosso problema)
• Fare clic su [ Save ]e disconnettersi da Jenkins e accedere nuovamente solo per assicurarsi che funzioni. In caso contrario, è necessario ricominciare da capo e svuotare la /opt/docker/jenkins/jenkins_homecartella prima di riavviare

Aggiungi l'utente git

Dobbiamo consentire al nostro hook git di accedere al nostro Jenkins locale con diritti minimi. Basta vedere e costruire posti di lavoro è sufficiente. Pertanto creiamo un utente chiamato gitcon passwordlogin .

Dirigere il browser su http: // localhost: 8787 / securityRealm / addUser e aggiungere gitcome nome utente e logincome password. Clicca su [ Create User ].

Aggiungi i diritti all'utente git

Vai alla pagina http: // localhost: 8787 / configureSecurity nel tuo browser. Aggiungi l'utente git alla matrice:

• Scrivi gitnel campo User/group to add:e fai clic su[ Add ]

Ora è il momento di selezionare le caselle per i diritti minimi per l'utente git. Sono necessari solo questi:

• nel complesso: Leggi
• lavoro: costruire
• lavoro: scopri
• lavoro: leggere

Assicurarsi che il Prevent Cross Site Request Forgery exploits casella di controllo sia deselezionata e fai clic su[ Save ]

Crea il progetto della pipeline

Partiamo dal presupposto che abbiamo il nome utente usere il nostro progetto abilitato git con Jenkinsfilein esso viene chiamato projecte si trova in/home/user/projects/project

Nel tuo http: // localhost: 8787 Jenkins aggiunge un nuovo progetto di pipeline. L'ho chiamato hookpipeline come riferimento.

• Fai clic su New Itemnel menu Jenkins
• Assegna un nome al progetto hookpipeline
• Fai clic su Pipeline
• Clic [ OK ]
• Spuntare la casella Poll SCMnella sezione Trigger della build. Lascia vuoto il programma.
• Nella sezione Pipeline:
  • Selezionare Pipeline script from SCM
  • nel Repository URLcampo inserireuser@172.17.0.1:projects/project/.git
  • nel Script Pathcampo inserireJenkinsfile
• Salvare il progetto hookpipeline
• Costruisci manualmente l'hookpipeline una volta, questo è necessario per far funzionare il SCM Poll.

Crea l'hook git

Vai alla /home/user/projects/project/.git/hookscartella e crea un file chiamato post-commitche contiene questo:

#!/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"

Rendi eseguibile questo file:

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

Testare l'hook post-commit:

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

Controlla in Jenkins se il tuo progetto hookpipeline è stato attivato.

Apporta infine alcune modifiche arbitrarie al tuo progetto, aggiungi le modifiche e fai un commit. Questo ora attiverà la pipeline nel tuo Jenkins locale.

Giorni felici!

TL; DR

• Quadro di collaudo Jenkins Pipeline Unit
• Jenkinsfile Runner

Versione lunga I
test della pipeline Jenkins diventano sempre più una seccatura. A differenza del classico approccio di configurazione del lavoro dichiarativo in cui l'utente era limitato a ciò che l'interfaccia utente esponeva la nuova pipeline Jenkins è un linguaggio di programmazione completo per il processo di costruzione in cui si mescola la parte dichiarativa con il proprio codice. Come bravi sviluppatori vogliamo fare anche alcuni test unitari per questo tipo di codice.

Ci sono tre passaggi da seguire durante lo sviluppo di Jenkins Pipelines. Il passaggio 1. dovrebbe coprire l'80% dei casi d'uso.

1. Fai il più possibile negli script di compilazione (ad es. Maven, Gradle, Gulp ecc.). Quindi nella tua pipeline gli script chiama semplicemente le attività di compilazione nel giusto ordine. La pipeline di compilazione orchestra ed esegue le attività di compilazione ma non ha alcuna logica importante che richiede un test speciale.
2. Se non è possibile applicare completamente la regola precedente, passare alle librerie condivise della pipeline in cui è possibile sviluppare e testare la logica personalizzata da solo e integrarli nella pipeline.
3. Se tutto quanto sopra non ti riesce, puoi provare una di quelle librerie che sono venute fuori di recente (marzo 2017). Framework di test Jenkins Pipeline Unit o pipelineUnit (esempi). Dal 2018 esiste anche Jenkinsfile Runner , un pacchetto per eseguire pipeline Jenkins da uno strumento da riga di comando.

Esempi

il pipelineUnit repo GitHub contiene alcuni esempi Spock su come utilizzare Jenkins Pipeline Unità quadro test

Jenkins ha una funzione 'Replay', che consente di riprodurre rapidamente un lavoro senza aggiornare le fonti:

Al momento della stesura (fine luglio 2017) con il plug-in Blue Ocean è possibile verificare la sintassi di una pipeline dichiarativa direttamente nell'editor della pipeline visiva . L'editor funziona dall'interfaccia utente di Blue Ocean quando si fa clic su "configura" solo per i progetti github (questo è un problema noto e stanno lavorando per farlo funzionare anche su git ecc.).

Ma, come spiegato in questa domanda , puoi aprire l'editor sfogliando:

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

Quindi fare clic al centro della pagina e premere Ctrl+S, questo aprirà un'area di testo in cui è possibile incollare uno script dichiarativo della pipeline. Quando fai clic su Aggiorna , se c'è un errore di sintassi, l'editor ti farà sapere dove si trova l'errore di sintassi. Come in questo screenshot:

Se non si verifica alcun errore di sintassi, l'area di testo verrà chiusa e la pagina visualizzerà la pipeline. Non preoccuparti, non salverà nulla (se si tratta di un progetto github, commetterebbe il cambio di file Jenkins).

Sono nuovo di Jenkins e questo è abbastanza utile, senza questo ho dovuto impegnare un file Jenkins molte volte, fino a quando non funziona (molto fastidioso!). Spero che questo ti aiuti. Saluti.

Un po 'tardi alla festa, ma è per questo che ho scritto jenny, una piccola reimplementazione di alcuni passaggi fondamentali di Jenkinsfile. ( https://github.com/bmustiata/jenny )

Per quanto ne so questo plugin Pipeline è il "Motore" della nuova meccanica di Jenkinsfile, quindi sono abbastanza sicuro che potresti usarlo per testare localmente i tuoi script.

Non sono sicuro che ci siano ulteriori passaggi necessari quando lo copi in un file Jenkins, tuttavia la sintassi ecc. Dovrebbe essere esattamente la stessa.

Modifica: trovato il riferimento sul "motore", controlla questa descrizione della funzione, ultimo paragrafo, prima voce.

Nella mia configurazione di sviluppo - mancando un editor Groovy appropriato - gran parte dei problemi di Jenkinsfile provengono da semplici errori di sintassi . Per affrontare questo problema, puoi convalidare il file Jenkins sulla tua istanza Jenkins (in esecuzione su $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

Il comando sopra è una versione leggermente modificata da https://github.com/jenkinsci/pipeline-model-definition-plugin/wiki/Validating-(or-linting)-a-Declarative-Jenkinsfile-from-the-command-line

A parte la funzione Replay che altri hanno già menzionato (idem sulla sua utilità!), Ho trovato utile anche quanto segue:

1. Creare un processo Pipeline di prova in cui è possibile digitare il codice Pipeline o puntare al proprio repository / ramo di un file Jenkins per testare rapidamente qualcosa. Per test più accurati, utilizzare una pipeline multibranch che punta al proprio fork in cui è possibile apportare rapidamente modifiche e impegnarsi senza influire sul prod. Cose come BRANCH_NAME env sono disponibili solo in Multibranch.
2. Poiché Jenkinsfile è il codice Groovy, è sufficiente invocarlo con "groovy Jenkinsfile" per convalidare la sintassi di base.

Inserisci la tua chiave SSH nel tuo profilo Jenkins, quindi usa la linter dichiarativa come segue:

ssh jenkins.hostname.here declarative-linter < Jenkinsfile

Questo farà un'analisi statica sul tuo Jenkinsfile. Nell'editor di tua scelta, definisci una scorciatoia da tastiera che esegue automaticamente quel comando. In Visual Studio Code, che è quello che uso, vai su Attività> Configura attività, quindi usa il seguente JSON per creare un comando Convalida Jenkinsfile :

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

sto usando Replay in futuro, per fare qualche aggiornamento ed eseguire rapidamente.

Con alcune limitazioni e per le pipeline con script utilizzo questa soluzione:

1. Processo di pipeline con uno script groovy integrato:

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

2. Il file Jenkins per i test ha la stessa struttura dei lesfuret:

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