Pipeline di Jenkins con script o pipeline dichiarativa

Sto cercando di convertire il mio flusso di lavoro di base del progetto vecchio stile in una pipeline basata su Jenkins. Durante la consultazione dei documenti ho scoperto che ci sono due diverse sintassi denominate scriptede declarative. Come il declarativerilascio della sintassi web di Jenkins di recente (fine 2016). Sebbene esista una nuova versione della sintassi, Jenkins supporta ancora anche la sintassi con script.

Ora, non sono sicuro in quale situazione ciascuno di questi due tipi sarebbe la migliore corrispondenza. scriptedla sintassi sarà presto deprecata? Quindi sarà declarativeil futuro del gasdotto Jenkins?

Chiunque possa condividere alcuni pensieri su questi due tipi di sintassi.

Quando è stato creato Jenkins Pipeline, Groovy è stato scelto come base. Jenkins è da tempo fornito con un motore Groovy incorporato per fornire funzionalità di scripting avanzate per amministratori e utenti. Inoltre, gli implementatori di Jenkins Pipeline hanno ritenuto che Groovy fosse una solida base su cui costruire quello che ora viene chiamato DSL "Scripted Pipeline".

Poiché si tratta di un ambiente di programmazione completo, Scripted Pipeline offre un'enorme quantità di flessibilità ed estensibilità agli utenti di Jenkins. La curva di apprendimento di Groovy non è in genere desiderabile per tutti i membri di un dato team, quindi la pipeline dichiarativa è stata creata per offrire una sintassi più semplice e più supponente per la creazione di Jenkins Pipeline.

I due sono fondamentalmente lo stesso sottosistema di pipeline sottostante. Sono entrambe implementazioni durevoli di "Pipeline as code". Sono entrambi in grado di utilizzare i passaggi incorporati in Pipeline o forniti dai plug-in. Entrambi sono in grado di utilizzare le librerie condivise

Dove differiscono tuttavia è nella sintassi e nella flessibilità. Dichiarativo limita ciò che è disponibile per l'utente con una struttura più rigida e predefinita, rendendolo una scelta ideale per pipeline di consegna continua più semplici. Scripted fornisce pochissimi limiti, nella misura in cui gli unici limiti sulla struttura e sulla sintassi tendono a essere definiti da Groovy stesso, piuttosto che da qualsiasi sistema specifico di Pipeline, rendendolo una scelta ideale per gli utenti esperti e quelli con requisiti più complessi. Come suggerisce il nome, Declarative Pipeline incoraggia un modello di programmazione dichiarativo. Mentre le pipeline con script seguono un modello di programmazione più imperativo.

Copiato da https://jenkins.io/doc/book/pipeline/syntax/#compare

Un'altra cosa da considerare è che le pipeline dichiarative hanno un'istruzione script () . Questo può eseguire qualsiasi pipeline con script. Quindi la mia raccomandazione sarebbe quella di utilizzare pipeline dichiarative e, se necessario, utilizzare script()per pipeline con script. Quindi ottieni il meglio da entrambi i mondi.

Di recente sono passato a dichiarativo da script con l'agente kubernetes. Fino al luglio '18 le pipeline dichiarative non avevano la piena capacità di specificare i pod kubernetes. Tuttavia, con l'aggiunta del yamlFilepassaggio ora puoi leggere il tuo modello di pod da un file yaml nel tuo repository.

Questo ti consente quindi di utilizzare, ad esempio, l'ottimo plug-in kubernetes di vscode per convalidare il tuo modello di pod, quindi leggerlo nel tuo Jenkinsfile e utilizzare i contenitori nei passaggi a tuo piacimento.

pipeline {
  agent {
    kubernetes {
      label 'jenkins-pod'
      yamlFile 'jenkinsPodTemplate.yml'
    }
  }
  stages {
    stage('Checkout code and parse Jenkinsfile.json') {
      steps {
        container('jnlp'){
          script{
            inputFile = readFile('Jenkinsfile.json')
            config = new groovy.json.JsonSlurperClassic().parseText(inputFile)
            containerTag = env.BRANCH_NAME + '-' + env.GIT_COMMIT.substring(0, 7)
            println "pipeline config ==> ${config}"
          } // script
        } // container('jnlp')
      } // steps
    } // stage

Come accennato in precedenza, puoi aggiungere blocchi di script. Esempio di modello di pod con jnlp personalizzato e docker.

apiVersion: v1
kind: Pod
metadata:
  name: jenkins-pod
spec:
  containers:
  - name: jnlp
    image: jenkins/jnlp-slave:3.23-1
    imagePullPolicy: IfNotPresent
    tty: true
  - name: rsync
    image: mrsixw/concourse-rsync-resource
    imagePullPolicy: IfNotPresent
    tty: true
    volumeMounts:
      - name: nfs
        mountPath: /dags
  - name: docker
    image: docker:17.03
    imagePullPolicy: IfNotPresent
    command:
    - cat
    tty: true
    volumeMounts:
      - name: docker
        mountPath: /var/run/docker.sock
  volumes:
  - name: docker
    hostPath:
      path: /var/run/docker.sock
  - name: nfs
    nfs:
      server: 10.154.0.3
      path: /airflow/dags

dichiarativo sembra essere l'opzione più a prova di futuro e quella che la gente consiglia. è l'unico che il Visual Pipeline Editor può supportare. supporta la convalida. e finisce per avere la maggior parte del potere dello scripting dato che puoi tornare allo script nella maggior parte dei contesti. di tanto in tanto qualcuno si presenta con un caso d'uso in cui non riescono a fare quello che vogliono con dichiarativo, ma generalmente si tratta di persone che utilizzano script da un po 'di tempo e queste lacune di funzionalità rischiano di colmare nel tempo.

più contesto: https://jenkins.io/blog/2017/02/03/declarative-pipeline-ga/

La documentazione di Jenkins spiega e confronta correttamente entrambi i tipi.

Per citare: "La pipeline con script offre un'enorme quantità di flessibilità ed estensibilità agli utenti di Jenkins. La curva di apprendimento di Groovy non è in genere desiderabile per tutti i membri di un dato team, quindi la pipeline dichiarativa è stata creata per offrire una sintassi più semplice e supponente per autore di Jenkins Pipeline.

I due sono fondamentalmente lo stesso sottosistema del gasdotto sottostante. "

Maggiori informazioni qui: https://jenkins.io/doc/book/pipeline/syntax/#compare

1. La pipeline dichiarativa è definita all'interno di un blocco etichettato come "pipeline" mentre la pipeline con script è definita all'interno di un "nodo".
2. Sintassi: la pipeline dichiarativa ha "Fasi", "Fasi"
3. Se la compilazione fallisce, quella dichiarativa ti offre un'opzione per riavviare la compilazione da quella fase di nuovo, il che non è vero nell'opzione con script
4. Se c'è qualche problema nello scripting, quello dichiarativo ti avviserà non appena creerai il lavoro ma in caso di script, passerà lo stadio che è 'Okay' e genererà un errore sullo stage che è 'Non ok'

Puoi anche fare riferimento a questo. Una lettura molto buona -> https://e.printstacktrace.blog/jenkins-scripted-pipeline-vs-declarative-pipeline-the-4-practical-differences/ @ Szymon.Stepniak https://stackoverflow.com/users/ 2194470 / szymon-stepniak? Tab = profilo

La pipeline dichiarativa è di gran lunga superiore alla pipeline con script . La pipeline dichiarativa è in grado di eseguire tutto ciò che la pipeline con script può eseguire utilizzando l' istruzione di script e ha molte funzionalità aggiuntive.

Inoltre, la pipeline dichiarativa supporta varie tecnologie come Docker o Kubernetes (vedere qui ).

La pipeline dichiarativa è anche più a prova di futuro. È ancora in fase di sviluppo e nuove funzionalità come la nuova funzionalità Matrix sono state aggiunte di recente alla fine del 2019.

tl; dr - La pipeline dichiarativa può fare tutto ciò che può fare la pipeline con script e anche di più.