Criar e Executar um Pipeline Básico do Jenkins

Introdução

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

Neste laboratório, você focará na sintaxe do 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 de Pipeline na interface web do Jenkins.
Escrever um Jenkinsfile básico usando a sintaxe declarativa.
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.
Usar variáveis de ambiente para gerenciar configurações.

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

Criar um Projeto de Pipeline no Jenkins

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

Abra o navegador Firefox a partir da interface da área de trabalho. O navegador abrirá automaticamente em http://localhost:8080, portanto, você não precisa inserir a URL manualmente. Nenhum login é necessário.
No painel do Jenkins, clique em New Item no menu à esquerda.
No campo Enter an item name, digite my-first-pipeline.
Selecione Pipeline na lista de tipos de projeto.
Clique no botão OK na parte inferior da página.

Criar projeto de Pipeline

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

Agora você criou um projeto de Pipeline vazio. No próximo passo, você criará um Jenkinsfile e configurará este projeto para utilizá-lo.

Configurar o SCM para Usar um Repositório Git Local

Agora você configurará seu projeto Jenkins para recuperar sua definição de pipeline de um repositório Git local servido dentro do contêiner do Jenkins. Isso mantém o laboratório independente da disponibilidade de rede externa, enquanto ainda utiliza o fluxo de trabalho real de Pipeline script from SCM.

O repositório de demonstração está localizado em: git://localhost/pipeline-demo.git

Vamos examinar o Jenkinsfile que o Jenkins carregará deste repositório:

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 de Declarative Pipeline inclui múltiplos estágios e demonstra conceitos fundamentais:

pipeline { ... }: O bloco principal que define todo o pipeline.
agent any: Instrui 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 agrupador 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 de shell.

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

Retorne à interface do Jenkins no seu navegador e navegue até a página do projeto my-first-pipeline.
Clique em Configure no menu à esquerda.
Role para baixo até a seção Pipeline.
Altere o menu suspenso Definition de "Pipeline script" para Pipeline script from SCM.
No menu suspenso SCM que aparece, selecione Git.
No campo Repository URL, insira: git://localhost/pipeline-demo.git
No campo Script Path, insira: Jenkinsfile
Clique em Save.

Configuração de Pipeline SCM

Seu projeto agora está configurado para executar o pipeline definido no repositório Git local.

Executar o Pipeline e Verificar a Saída

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

Na página do projeto my-first-pipeline, clique em Build Now no menu à esquerda.
Um novo build será agendado e aparecerá no painel Build History à esquerda. Abaixo do histórico, a Stage View mostrará o estágio "Build" sendo executado e ficando verde após a conclusão.
Para ver a saída detalhada, clique no número do build (por exemplo, #1) no Build History.
Na página de resumo do build, clique em Console Output no menu à esquerda.
Percorra o log. Você encontrará as mensagens dos passos do seu pipeline, confirmando que ele 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) definidos no Jenkinsfile do repositório.

Entender 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 local 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!"'
        }
    }
}

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.
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 o build avança por cada um deles.
Clique em qualquer estágio na Stage View para ver os logs detalhados daquele estágio específico.
Observe como cada estágio é executado sequencialmente - o Jenkins aguarda a conclusão bem-sucedida de um estágio antes de passar para o próximo.

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

Entender Variáveis de Ambiente em um Pipeline

Neste passo 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 precisar codificá-las diretamente nos seus passos.

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

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

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

Pontos-chave sobre variáveis de ambiente nos Pipelines do Jenkins:

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.VARIABLE_NAME}.
É 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 com aspas duplas.
Variáveis de ambiente tornam seus pipelines mais flexíveis e fáceis de manter.

Se ainda não o fez, dispare um novo build no Jenkins clicando em Build Now.
Após a conclusão do build, verifique o Console Output do 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

Observe como o valor staging da variável de ambiente DEPLOY_TARGET foi substituído automaticamente 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, homologação, produção) sem modificar o código do pipeline em si.

Resumo

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

Neste laboratório, você praticou como:

Criar um projeto de Pipeline na interface do Jenkins.
Configurar um projeto para usar um Jenkinsfile de um repositório Git local servido ao Jenkins.
Entender a estrutura de um Declarative Pipeline com múltiplos estágios.
Executar um pipeline e inspecionar sua saída no console.
Observar como os pipelines são estruturados em estágios lógicos para clareza e organização.
Entender 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.

Introdução aos Pipelines do Jenkins