Pipeline com script Jenkins ou pipeline declarativo

Estou tentando converter meu fluxo de trabalho de base de projeto de estilo antigo em um pipeline baseado em Jenkins. Ao examinar os documentos , descobri que existem duas sintaxes diferentes chamadas scriptede declarative. Como o declarativelançamento de sintaxe da Web do Jenkins recentemente (final de 2016). Embora haja uma nova versão de sintaxe, o Jenkins ainda oferece suporte à sintaxe com script.

Agora, não tenho certeza em qual situação cada um desses dois tipos seria uma melhor correspondência. scripteda sintaxe será descontinuada em breve? Então será declarativeo futuro do pipeline do Jenkins?

Qualquer pessoa que possa compartilhar algumas idéias sobre esses dois tipos de sintaxe.

Quando o Jenkins Pipeline foi criado pela primeira vez, o Groovy foi escolhido como base. O Jenkins há muito vem com um mecanismo Groovy integrado para fornecer recursos de script avançados para administradores e usuários. Além disso, os implementadores do Jenkins Pipeline descobriram que o Groovy é uma base sólida sobre a qual construir o que agora é conhecido como DSL "Scripted Pipeline".

Por ser um ambiente de programação completo, o Scripted Pipeline oferece uma enorme flexibilidade e extensibilidade para os usuários do Jenkins. A curva de aprendizado do Groovy não é normalmente desejável para todos os membros de uma determinada equipe, portanto, o Pipeline declarativo foi criado para oferecer uma sintaxe mais simples e opinativa para a autoria do Jenkins Pipeline.

Os dois são fundamentalmente o mesmo subsistema de Pipeline por baixo. Ambos são implementações duráveis ​​de "Pipeline como código". Ambos podem usar etapas integradas ao Pipeline ou fornecidas por plug-ins. Ambos são capazes de utilizar bibliotecas compartilhadas

Onde eles diferem, entretanto, é na sintaxe e flexibilidade. A declaração limita o que está disponível para o usuário com uma estrutura mais rígida e pré-definida, tornando-se a escolha ideal para pipelines de entrega contínua mais simples. Scripted fornece poucos limites, na medida em que os únicos limites na estrutura e sintaxe tendem a ser definidos pelo próprio Groovy, ao invés de qualquer sistema específico do Pipeline, tornando-o uma escolha ideal para usuários avançados e aqueles com requisitos mais complexos. Como o nome indica, o Pipeline declarativo incentiva um modelo de programação declarativo. Enquanto os pipelines com script seguem um modelo de programação mais imperativo.

Copiado de https://jenkins.io/doc/book/pipeline/syntax/#compare

Outra coisa a se considerar é que os pipelines declarativos têm uma etapa script () . Isso pode executar qualquer pipeline com script. Portanto, minha recomendação seria usar pipelines declarativos e, se necessário, usar script()pipelines com script. Portanto, você obtém o melhor dos dois mundos.

Mudei recentemente para declarativo do script com o agente kubernetes. Até julho de 18, os pipelines declarativos não tinham a capacidade total de especificar pods de kubernetes. No entanto, com a adição da yamlFileetapa, agora você pode ler seu modelo de pod de um arquivo yaml em seu repo.

Isso então permite que você use, por exemplo, o ótimo plugin kubernetes do vscode para validar seu modelo de pod, em seguida, leia-o em seu Jenkinsfile e use os contêineres nas etapas que desejar.

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

Conforme mencionado acima, você pode adicionar blocos de script. Exemplo de modelo de pod com jnlp e docker personalizados.

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

declarativa parece ser a opção mais preparada para o futuro e aquela que as pessoas recomendam. é o único que o Visual Pipeline Editor pode suportar. ele suporta validação. e acaba tendo a maior parte do poder do script, pois você pode recorrer ao script na maioria dos contextos. ocasionalmente, alguém surge com um caso de uso em que não consegue fazer exatamente o que deseja com o declarativo, mas geralmente são pessoas que usam scripts há algum tempo e essas lacunas de recursos provavelmente se fecharão com o tempo.

mais contexto: https://jenkins.io/blog/2017/02/03/declarative-pipeline-ga/

A documentação do Jenkins explica e compara adequadamente os dois tipos.

Para citar: "O Pipeline com script oferece uma quantidade enorme de flexibilidade e extensibilidade para os usuários do Jenkins. A curva de aprendizado do Groovy não é normalmente desejável para todos os membros de uma determinada equipe, então o Pipeline declarativo foi criado para oferecer uma sintaxe mais simples e opinativa para autoria do Jenkins Pipeline.

Os dois são fundamentalmente o mesmo subsistema de Pipeline por baixo. "

Leia mais aqui: https://jenkins.io/doc/book/pipeline/syntax/#compare

1. O pipeline declarativo é definido dentro de um bloco denominado 'pipeline', enquanto o pipeline com script é definido dentro de um 'nó'.
2. Sintaxe - pipeline declarativo tem 'Estágios', 'Etapas'
3. Se a compilação falhar, o declarativo oferece a opção de reiniciar a compilação a partir desse estágio novamente, o que não é verdade na opção com script
4. Se houver algum problema no script, o declarativo irá notificá-lo assim que você construir o trabalho, mas no caso do script, ele passará do estágio que está 'Ok' e lançará um erro no estágio que está 'Não ok'

Você também pode consultar isso. Uma leitura muito boa -> https://e.printstacktrace.blog/jenkins-scripted-pipeline-vs-declarative-pipeline-the-4-practical-differences/ @ Szymon.Stepniak https://stackoverflow.com/users/ 2194470 / szymon-stepniak? Tab = profile

O Pipeline declarativo é muito superior ao Pipeline com script . O pipeline declarativo é capaz de executar tudo o que o pipeline com script pode, usando a etapa de script e tem muitos recursos adicionais.

Além disso, o Pipeline declarativo tem suporte para várias tecnologias como Docker ou Kubernetes (veja aqui ).

O pipeline declarativo também é mais preparado para o futuro. Ele ainda está em desenvolvimento e novos recursos, como o recém-introduzido recurso Matrix , foram adicionados recentemente, no final de 2019.

tl; dr - Pipeline declarativo pode fazer tudo que o Pipeline com script pode fazer e ainda mais.