Introdução ao Jenkins 2 e o poder dos oleodutos

1. Visão geral

Neste artigo, vamos mostrar o uso de pipelines por meio de um exemplo de entrega contínua usandoJenkins.

Vamos construir um pipeline simples, mas bastante útil, para nosso projeto de amostra:

Compilação
Análise estática simples (paralela à compilação)
Testes unitários
Testes de integração (paralelos aos testes de unidade)
Desdobramento, desenvolvimento

2. Configurando o Jenkins

Em primeiro lugar, precisamos baixar a versão estável mais recente deJenkins (2.73.3 no momento da redação deste artigo).

Vamos navegar até a pasta onde está nosso arquivo e executá-lo usando o comandojava -jar jenkins.war. Keep in mind that we can’t use Jenkins without an initial users setup.

Depois de desbloquear o Jenkins usando a senha inicial gerada pelo administrador, devemos preencher as informações de perfil do primeiro usuário administrador e instalar todos os plug-ins recomendados.

Agora temos uma nova instalação do Jenkins pronta para ser usada.

Todas as versões disponíveis do Jenkins podem ser encontradashere.

3. Tubulações

O Jenkins 2 vem com um ótimo recurso chamadoPipelines, que é muito extensível quando precisamos definir um ambiente de integração contínua para um projeto.

A Pipeline is another way of defining some Jenkins steps using code, e automatizar o processo de implantação de software.

Ele está usando umDomain Specific Language(DSL) com duas sintaxes diferentes:

Pipeline Declarativo
Pipeline com script

Em nossos exemplos, vamos usarthe Scripted Pipeline which is following a more imperative programming model built with Groovy.

Vejamos algumas características do pluginPipeline:

pipelines são gravados em um arquivo de texto e tratados como código; isso significa que eles podem ser adicionados ao controle de versão e modificados posteriormente
eles permanecerão após a reinicialização do servidor Jenkins
opcionalmente, podemos pausar pipelines
eles suportam requisitos complexos, como a execução de trabalhos em paralelo
o plugin Pipeline também pode ser estendido ou integrado a outros plugins

Em outras palavras, configurar um projeto de Pipeline significa escrever um script que aplicará sequencialmente algumas etapas do processo que queremos realizar.

To start using pipelines we have to install the Pipeline plugin que permite compor automações simples e complexas.

Podemos opcionalmente ter oPipeline Stage View um também para que, quando executarmos uma compilação, veremos todos os estágios que configuramos.

4. Um Exemplo Rápido

Para nosso exemplo, usaremos um pequeno aplicativo Spring Boot. Em seguida, criaremos um pipeline que clona o projeto, o constrói e executa vários testes, em seguida, executa o aplicativo.

Vamos instalar os plug-ins*https://wiki.jenkins-ci.org/display/JENKINS/Checkstyle+Plugin[Checkstyle],*Static Analysis Collector eJUnit, que são respectivamente úteis para coletar os resultados deCheckstyle, construir um gráfico de análise combinado dos relatórios de teste e ilustrar os testes executados com sucesso e os que falharam .

Em primeiro lugar, vamos entender a razão do Checkstyle aqui: é uma ferramenta de desenvolvimento que ajuda os programadores a escrever um código Java melhor seguindo padrões aceitos e conhecidos.

O Static Analysis Collector é um complemento que coleta diferentes saídas de análise e imprime os resultados em um gráfico de tendências combinado. Além disso, o plug-in fornece relatórios de integridade e cria estabilidade com base nesses resultados agrupados.

Finalmente, o plug-inJUnit fornece um editor que consome relatórios de teste XML gerados durante as compilações e fornece informações detalhadas e significativas em relação aos testes de um projeto.

Também configuraremosCheckstyle empom.xml: do nosso aplicativo


    org.apache.maven.plugins
    maven-checkstyle-plugin
    2.17

5. Criação de um script de pipeline

Primeiro, precisamos criar um novo emprego de Jenkins. Vamos ter certeza de selecionarPipeline como o tipo antes de clicar no botão OK, conforme descrito nesta captura de tela:

A próxima tela nos permite preencher mais detalhes das diferentes etapas de nosso trabalho no Jenkins, comodescription,triggers, algunsadvanced project options:

Vamos mergulhar na parte principal e mais importante desse tipo de trabalho clicando na guiaPipeline.

Então, para a definição, selecionePipeline script ** e marqueUse Groovy Sandbox.

Aqui está o script de trabalho para um ambiente Unix:

node {
    stage 'Clone the project'
    git 'https://github.com/eugenp/tutorials.git'

    dir('spring-jenkins-pipeline') {
        stage("Compilation and Analysis") {
            parallel 'Compilation': {
                sh "./mvnw clean install -DskipTests"
            }, 'Static Analysis': {
                stage("Checkstyle") {
                    sh "./mvnw checkstyle:checkstyle"

                    step([$class: 'CheckStylePublisher',
                      canRunOnFailed: true,
                      defaultEncoding: '',
                      healthy: '100',
                      pattern: '**/target/checkstyle-result.xml',
                      unHealthy: '90',
                      useStableBuildAsReference: true
                    ])
                }
            }
        }

        stage("Tests and Deployment") {
            parallel 'Unit tests': {
                stage("Runing unit tests") {
                    try {
                        sh "./mvnw test -Punit"
                    } catch(err) {
                        step([$class: 'JUnitResultArchiver', testResults:
                          '**/target/surefire-reports/TEST-*UnitTest.xml'])
                        throw err
                    }
                   step([$class: 'JUnitResultArchiver', testResults:
                     '**/target/surefire-reports/TEST-*UnitTest.xml'])
                }
            }, 'Integration tests': {
                stage("Runing integration tests") {
                    try {
                        sh "./mvnw test -Pintegration"
                    } catch(err) {
                        step([$class: 'JUnitResultArchiver', testResults:
                          '**/target/surefire-reports/TEST-'
                            + '*IntegrationTest.xml'])
                        throw err
                    }
                    step([$class: 'JUnitResultArchiver', testResults:
                      '**/target/surefire-reports/TEST-'
                        + '*IntegrationTest.xml'])
                }
            }

            stage("Staging") {
                sh "pid=\$(lsof -i:8989 -t); kill -TERM \$pid "
                  + "|| kill -KILL \$pid"
                withEnv(['JENKINS_NODE_COOKIE=dontkill']) {
                    sh 'nohup ./mvnw spring-boot:run -Dserver.port=8989 &'
                }
            }
        }
    }
}

Primeiro, estamos clonando o repositório do GitHub e, em seguida, alterando o diretório para o nosso projeto, que é chamadospring-jenkins-pipeline.

A seguir, compilamos o projeto e aplicamos a análiseCheckstyle de forma paralela.

A etapa a seguir representa uma execução paralela de testes de unidade e de integração e, em seguida, a implantação do aplicativo.

Parallelism is used to optimize the pipeline, and have the job runs faster. É uma prática recomendada no Jenkins executar simultaneamente algumas ações independentes que podem levar muito tempo.

Por exemplo, em um projeto do mundo real, geralmente temos muitos testes de unidade e integração que podem levar mais tempo.

Observe que, se algum teste falhar, o BUILD também será marcado como FAILED e a implantação não ocorrerá.

Além disso, estamos usandoJENKINS_NODE_COOKIE para evitar o desligamento imediato de nosso aplicativo quando o pipeline chega ao fim.

Para ver um script mais geral funcionando em outros sistemas diferentes, verifique oGitHub repository.

6. Relatório de análise

Depois de criar o trabalho, salvaremos nosso script e clicaremosBuild Now na página inicial do projeto de nosso painel do Jenkins.

Esta é uma visão geral das compilações:

Um pouco mais abaixo, encontraremos a visualização do estágio do pipeline, com o resultado de cada estágio:

Cada saída é acessível ao passar o mouse sobre uma célula de estágio e clicar no botãoLogs para ver as mensagens de log impressas nessa etapa.

Também podemos encontrar mais detalhes da análise de código. Vamos clicar na construção desejada emBuild History no menu à direita e clicar emCheckstyle Warnings.

Aqui vemos 60 avisos de alta prioridade navegáveis clicando em:

A guiaDetails exibe informações que destacam os avisos e permitem que o desenvolvedor entenda as causas por trás deles.

Da mesma forma, o relatório de teste completo pode ser acessado clicando no linkTest Result. Vamos ver os resultados do pacotecom.example:

Aqui podemos ver cada arquivo de teste com sua duração e status.

7. Conclusão

Neste artigo, configuramos um ambiente de entrega contínua simples para executar e mostrar análise de código estático e relatório de teste no Jenkins por meio de um trabalhoPipeline.

Como sempre, o código-fonte deste artigo pode ser encontradoover on GitHub.

TOC

Introdução ao Jenkins 2 e o poder dos oleodutos