Introdução aos Jenkins Pipelines

Introdução

Bem-vindo a este laboratório sobre os fundamentos dos Jenkins Pipelines. Jenkins Pipeline é um recurso poderoso que permite definir todo o seu processo de build, teste e deploy como código. Esta definição é armazenada em um arquivo de texto chamado Jenkinsfile, que é tipicamente versionado junto com o código-fonte da sua aplicação. Esta prática é conhecida como "Pipeline-as-Code".

Neste laboratório, você se concentrará na sintaxe Declarative Pipeline, que oferece uma maneira estruturada e amigável de criar pipelines. Ao final deste laboratório, você será capaz de:

• Criar um novo projeto Pipeline na interface web do Jenkins.
• Escrever um Jenkinsfile básico usando a sintaxe Declarative.
• Configurar um projeto para usar um Jenkinsfile de um repositório Git local.
• Executar um pipeline e inspecionar sua saída.
• Organizar um pipeline em múltiplos estágios (stages).
• Usar variáveis de ambiente para gerenciar a configuração.

Uma instância do Jenkins já está em execução em um contêiner para você. Vamos começar.

Criar um Projeto Pipeline no Jenkins

Seu primeiro passo é criar um novo projeto do tipo Pipeline no Jenkins. Este tipo de projeto é especificamente projetado para executar pipelines definidos em um Jenkinsfile.

1. Abra o navegador Firefox na interface de desktop. O navegador abrirá automaticamente em http://localhost:8080, então você não precisa digitar o URL manualmente. Nenhum login é necessário.
2. No painel (dashboard) do Jenkins, clique em New Item (Novo Item) no menu à esquerda.
3. No campo Enter an item name (Insira um nome de item), digite my-first-pipeline.
4. Selecione Pipeline na lista de tipos de projeto.
5. Clique no botão OK na parte inferior da página.

8. Você será levado para a página de configuração do projeto. Por enquanto, deixaremos as configurações como estão. Role até o final e clique em Save (Salvar).

Você acabou de criar um projeto Pipeline vazio. Na próxima etapa, você criará um Jenkinsfile e configurará este projeto para utilizá-lo.

Configurar SCM para Usar Repositório Remoto

Agora você configurará seu projeto Jenkins para buscar sua definição de pipeline de um repositório Git remoto. Usaremos um repositório de demonstração que contém um Jenkinsfile pré-configurado e uma aplicação de exemplo.

O repositório de demonstração está localizado em: https://github.com/labex-labs/jenkins-demo

Vamos examinar o Jenkinsfile que usaremos do repositório remoto:

pipeline {
    agent any
    environment {
        DEPLOY_TARGET = 'staging'
    }
    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
                sh 'echo "Compiling source code..."'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing the application...'
                sh 'echo "Running unit tests..."'
            }
        }
        stage('Deploy') {
            steps {
                echo "Deploying the application to ${env.DEPLOY_TARGET}..."
                sh 'echo "Application deployed successfully!"'
            }
        }
    }
}

Este script Declarative Pipeline inclui múltiplos estágios e demonstra conceitos chave:

• pipeline { ... }: O bloco principal que define todo o pipeline.
• agent any: Instruí o Jenkins a executar este pipeline em qualquer agente disponível.
• environment { ... }: Define variáveis de ambiente que podem ser usadas em todo o pipeline.
• stages { ... }: Um contêiner para todos os estágios do pipeline.
• stage('...') { ... }: Define estágios específicos. Os estágios ajudam a visualizar o fluxo de trabalho.
• steps { ... }: Contém os comandos reais a serem executados em um estágio.
• echo '...': Um passo que imprime uma mensagem no log de build.
• sh '...': Um passo que executa comandos shell.

Agora, configure seu projeto Jenkins para usar este repositório remoto:

1. Retorne à interface do Jenkins no seu navegador e navegue até a página do projeto my-first-pipeline.
2. Clique em Configure no menu à esquerda.
3. Role para baixo até a seção Pipeline.
4. Altere o dropdown Definition de "Pipeline script" para Pipeline script from SCM.
5. No dropdown SCM que aparece, selecione Git.
6. No campo Repository URL, insira: https://github.com/labex-labs/jenkins-demo
7. No campo Script Path, insira: introduction-to-pipelines/Jenkinsfile
8. Clique em Save.

Seu projeto agora está configurado para executar o pipeline definido no repositório remoto do GitHub.

Executar o Pipeline e Verificar a Saída

Com seu projeto configurado, é hora de executar o pipeline e vê-lo em ação.

1. Na página do projeto my-first-pipeline, clique em Build Now no menu à esquerda.

2. Uma nova build será agendada e aparecerá no painel Build History à esquerda. Abaixo do histórico, a Stage View mostrará o estágio "Build" em execução e, em seguida, ficando verde ao ser concluído.

   

3. Para ver a saída detalhada, clique no número da build (por exemplo, #1) no Build History.

4. Na página de resumo da build, clique em Console Output no menu à esquerda.

   

5. Percorra o log. Você encontrará as mensagens dos seus passos do pipeline, confirmando que seu pipeline foi executado com sucesso.

...
[Pipeline] { (Build)
[Pipeline] echo
Building the application...
[Pipeline] sh
+ echo Compiling source code...
Compiling source code...
[Pipeline] } // stage
[Pipeline] { (Test)
[Pipeline] echo
Testing the application...
[Pipeline] sh
+ echo Running unit tests...
Running unit tests...
[Pipeline] } // stage
[Pipeline] { (Deploy)
[Pipeline] echo
Deploying the application to staging...
[Pipeline] sh
+ echo Application deployed successfully!
Application deployed successfully!
[Pipeline] } // stage
...
Finished: SUCCESS

Você executou com sucesso seu primeiro pipeline e verificou sua saída. Observe como o pipeline executou automaticamente todos os três estágios (Build, Test, Deploy) que foram definidos no Jenkinsfile do repositório remoto.

Compreender Múltiplos Estágios no Pipeline

Pipelines do mundo real são compostos por múltiplos estágios, como compilar, testar e implantar uma aplicação. O Jenkinsfile do repositório remoto já inclui esses estágios distintos, demonstrando este conceito importante.

Vamos examinar como o pipeline é estruturado com múltiplos estágios:

stages {
    stage('Build') {
        steps {
            echo 'Building the application...'
            sh 'echo "Compiling source code..."'
        }
    }
    stage('Test') {
        steps {
            echo 'Testing the application...'
            sh 'echo "Running unit tests..."'
        }
    }
    stage('Deploy') {
        steps {
            echo "Deploying the application to ${env.DEPLOY_TARGET}..."
            sh 'echo "Application deployed successfully!"'
        }
    }
}

1. Volte para a interface do Jenkins para o projeto my-first-pipeline e clique em Build Now para executar o pipeline novamente, caso ainda não o tenha feito.

2. Observe a Stage View no painel do projeto. Você verá três colunas representando seus estágios "Build", "Test" e "Deploy". O Jenkins visualiza o progresso à medida que a build avança por cada um deles.

   

3. Clique em qualquer estágio na Stage View para ver os logs detalhados desse estágio específico.

4. Observe como cada estágio é executado sequencialmente – o Jenkins espera que um estágio seja concluído com sucesso antes de passar para o próximo estágio.

Ao estruturar seu pipeline com estágios, você cria um fluxo de trabalho claro e mantenível que é fácil de monitorar. Cada estágio representa uma fase lógica em seu processo de CI/CD, facilitando a identificação de onde ocorrem problemas e a visualização do progresso de suas builds.

Compreender Variáveis de Ambiente em um Pipeline

Nesta etapa final, você aprenderá sobre variáveis de ambiente. A diretiva environment permite definir variáveis que podem ser usadas em todo o seu pipeline, o que é ideal para gerenciar configurações sem codificá-las diretamente em seus passos.

O Jenkinsfile do repositório remoto já demonstra este conceito com uma variável de ambiente que especifica um alvo de implantação.

Vamos examinar como as variáveis de ambiente são definidas e usadas:

pipeline {
    agent any
    environment {
        DEPLOY_TARGET = 'staging'
    }
    stages {
        // ... other stages ...
        stage('Deploy') {
            steps {
                echo "Deploying the application to ${env.DEPLOY_TARGET}..."
                sh 'echo "Application deployed successfully!"'
            }
        }
    }
}

Pontos chave sobre variáveis de ambiente em Jenkins Pipelines:

• O bloco environment { ... } define variáveis que estão disponíveis em todo o pipeline.
• As variáveis são acessadas usando a sintaxe ${env.NOME_DA_VARIÁVEL}.
• É crucial usar aspas duplas (") para strings com interpolação de variáveis, pois a interpolação de variáveis do Groovy só funciona dentro de strings entre aspas duplas.
• Variáveis de ambiente tornam seus pipelines mais flexíveis e fáceis de manter.

1. Se você ainda não o fez, acione uma nova build no Jenkins clicando em Build Now.

2. Após a conclusão da build, verifique o Console Output da build. No log do estágio "Deploy", você verá que a variável foi substituída corretamente:

...
[Pipeline] { (Deploy)
[Pipeline] echo
Deploying the application to staging...
[Pipeline] sh
+ echo Application deployed successfully!
Application deployed successfully!
[Pipeline] } // stage
...
Finished: SUCCESS

3. Observe como o valor da variável de ambiente DEPLOY_TARGET, staging, foi automaticamente substituído na instrução echo.

Variáveis de ambiente são essenciais para criar pipelines flexíveis que podem ser facilmente configurados para diferentes ambientes (desenvolvimento, staging, produção) sem modificar o próprio código do pipeline.

Resumo

Parabéns! Você concluiu com sucesso esta introdução aos Jenkins Pipelines. Você aprendeu os conceitos centrais de definir um fluxo de trabalho de CI/CD como código.

Neste laboratório, você praticou como:

• Criar um projeto Pipeline na interface do Jenkins.
• Configurar um projeto para usar um Jenkinsfile de um repositório Git remoto (SCM).
• Compreender a estrutura de um Pipeline Declarativo com múltiplos estágios.
• Executar um pipeline e inspecionar sua saída de console.
• Observar como os pipelines são estruturados em estágios lógicos para clareza e organização.
• Compreender como as variáveis de ambiente são definidas e usadas para tornar os pipelines mais dinâmicos.

Essas habilidades fundamentais são essenciais para construir pipelines de automação sofisticados. Agora você está pronto para explorar tópicos mais avançados, como o uso de parâmetros, gerenciamento de credenciais e integração com várias ferramentas de build e implantação.