Parametrizando Builds e Usando Scripts

Introdução

Em pipelines de CI/CD modernos, a flexibilidade e a automação são fundamentais. Codificar valores diretamente nos jobs de build os torna rígidos e difíceis de gerenciar. O Jenkins permite que você supere isso parametrizando seus builds e executando scripts como parte do processo de build.

Neste laboratório, você aprenderá a criar um job flexível no Jenkins. Você começará adicionando parâmetros para permitir a entrada do usuário no momento do build. Em seguida, aprenderá a executar scripts shell como uma etapa de build, passar os parâmetros para esses scripts e configurar ações pós-build que respondem condicionalmente ao sucesso ou falha do build. Essas são habilidades fundamentais para criar fluxos de trabalho de automação robustos e dinâmicos no Jenkins.

Uma instância do Jenkins já está em execução no seu ambiente. Você pode acessar a interface web do Jenkins abrindo o navegador Firefox na área de trabalho. O navegador abrirá automaticamente em http://localhost:8080, portanto, você não precisa inserir a URL manualmente. Nenhum login é necessário.

Criar e Parametrizar um Projeto Freestyle

Nesta etapa, você criará um novo projeto Freestyle no Jenkins e adicionará parâmetros a ele. Os parâmetros tornam seus jobs interativos, permitindo que você forneça entradas sempre que um build for acionado.

Primeiro, vamos criar o job.

1. 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.
2. No painel do Jenkins, clique em New Item no menu à esquerda.
3. Insira parameterized-script-job como o nome do item.
4. Selecione Freestyle project e clique em OK.

Você será levado à página de configuração do job. Agora, vamos adicionar parâmetros.

1. Na seção General, marque a caixa This project is parameterized.

   

2. Clique no menu suspenso Add Parameter e selecione String Parameter.

   • Name: GREETING_NAME
   • Default Value: World
   • Description: Enter a name to be greeted.

3. Clique no menu suspenso Add Parameter novamente e selecione Choice Parameter.

   • Name: ENVIRONMENT

   • Choices: (Insira cada opção em uma nova linha)

     DEV
     STAGING
     PROD
     

   • Description: Select the deployment environment.

Esses parâmetros estarão disponíveis para uso em etapas de build posteriores.

Por fim, role até a parte inferior e clique em Save. Você será redirecionado para a página principal do job, onde verá uma opção Build with Parameters em vez de "Build Now".

Adicionar uma Etapa de Build com Script Shell

Nesta etapa, você adicionará um script shell ao processo de build do seu job. Esta é uma maneira comum de realizar tarefas como compilar código, executar testes ou implantar aplicativos.

1. Navegue até o painel do parameterized-script-job no Jenkins.
2. Clique em Configure no menu à esquerda.
3. Role para baixo até a seção Build Steps.
4. Clique no menu suspenso Add build step e selecione Execute shell.
5. Na área de texto Command, insira o seguinte script. Este script criará uma estrutura de diretórios de projeto dentro do workspace do Jenkins e listará seu conteúdo.

echo "--- Starting Build Step ---"
echo "Current directory:"
pwd
echo "Creating project directory structure:"
mkdir -p my-app
echo "Version 1.0" > my-app/version.txt
echo "Listing files in the project directory:"
ls -la my-app
echo "--- Build Step Finished ---"

6. Clique em Save para aplicar as alterações.

Agora, vamos executar o job para ver o script em ação.

1. Na página do job, clique em Build with Parameters.
2. Mantenha os valores padrão dos parâmetros e clique no botão Build.
3. Um novo build aparecerá no Build History à esquerda. Clique no número do build (por exemplo, #1).
4. Clique em Console Output para visualizar os logs.

Você deverá ver a saída do seu script shell, incluindo a listagem de arquivos.

Started by user unknown or anonymous
Running as SYSTEM
Building in workspace /var/jenkins_home/workspace/parameterized-script-job
[parameterized-script-job] $ /bin/sh -xe /tmp/jenkins....sh
+ echo --- Starting Build Step ---
--- Starting Build Step ---
+ echo Current directory:
Current directory:
+ pwd
/var/jenkins_home/workspace/parameterized-script-job
+ echo Creating project directory structure:
Creating project directory structure:
+ mkdir -p my-app
+ echo Version 1.0
+ echo Listing files in the project directory:
Listing files in the project directory:
+ ls -la my-app
total 12
drwxr-xr-x 2 jenkins jenkins 4096 ... .
drwxr-xr-x 3 jenkins jenkins 4096 ... ..
-rw-r--r-- 1 jenkins jenkins   12 ... version.txt
+ echo --- Build Step Finished ---
--- Build Step Finished ---
Finished: SUCCESS

Passar Parâmetros para o Script Shell

Nesta etapa, você aprenderá como usar os parâmetros definidos na Etapa 1 dentro do seu script shell. O Jenkins expõe os parâmetros de build como variáveis de ambiente, que você pode acessar no seu script usando a sintaxe $VARIABLE_NAME.

1. Volte para a página Configure do seu parameterized-script-job.
2. Role para baixo até a seção Build Steps e encontre a caixa de comando Execute shell.
3. Substitua o script existente pelo seguinte:

echo "--- Starting Parameterized Build Step ---"
echo "Hello, $GREETING_NAME!"
echo "Deploying to the $ENVIRONMENT environment."

## Create project structure if not exists and read the version from the file
mkdir -p my-app
echo "Version 1.0" > my-app/version.txt
APP_VERSION=$(cat my-app/version.txt)
echo "Application version is: $APP_VERSION"
echo "--- Parameterized Build Step Finished ---"

Observe como $GREETING_NAME e $ENVIRONMENT são usados diretamente nos comandos echo. Quando o job for executado, o Jenkins substituirá essas variáveis pelos valores selecionados pelo usuário.

4. Clique em Save.

Agora, vamos executar o build com parâmetros personalizados.

1. Clique em Build with Parameters.
2. Altere GREETING_NAME para LabEx.
3. Selecione STAGING no menu suspenso ENVIRONMENT.
4. Clique em Build.
5. Verifique o Console Output do novo build.

A saída agora deve refletir os valores personalizados que você forneceu.

--- Starting Parameterized Build Step ---
+ echo Hello, LabEx!
Hello, LabEx!
+ echo Deploying to the STAGING environment.
Deploying to the STAGING environment.
+ mkdir -p my-app
+ echo Version 1.0
+ cat my-app/version.txt
+ APP_VERSION=Version 1.0
+ echo Application version is: Version 1.0
Application version is: Version 1.0
+ echo --- Parameterized Build Step Finished ---
--- Parameterized Build Step Finished ---

Lidar com Falhas de Build com Condições Shell

Nesta etapa, você simulará uma falha de build diretamente no script shell. Esta é uma maneira confiável de fazer com que um job Freestyle pare quando uma regra de implantação for violada.

Modificar o Script para Simular Falha

Agora, vamos modificar o script para falhar sob uma condição específica.

1. Vá para a página Configure do seu parameterized-script-job.
2. Na caixa de comando Execute shell, substitua o script pelo seguinte:

echo "Deploying to the $ENVIRONMENT environment."

if [ "$ENVIRONMENT" = "PROD" ]; then
  echo "Error: Production deployment is not allowed!"
  echo "Failure handled by shell condition."
  exit 1
fi

echo "Deployment to $ENVIRONMENT was successful."

Este script verifica o parâmetro ENVIRONMENT. Se ele estiver definido como PROD, ele imprime um erro e sai com um código de status 1. Em scripts shell, qualquer código de saída diferente de zero sinaliza uma falha para o Jenkins.

3. Clique em Save.

Testar a Condição de Falha

Agora, vamos testar a condição de falha.

1. Clique em Build with Parameters.
2. Selecione PROD para o ENVIRONMENT e clique em Build.
3. O build falhará, indicado por um ícone vermelho no Build History.
4. Verifique o Console Output. Você verá a mensagem de erro do seu script e o status final do build do Jenkins.

Deploying to the PROD environment.
+ [ PROD = PROD ]
+ echo Error: Production deployment is not allowed!
Error: Production deployment is not allowed!
+ echo Failure handled by shell condition.
Failure handled by shell condition.
+ exit 1
Build step 'Execute shell' marked build as failure
Finished: FAILURE

Se você executar o build novamente com DEV ou STAGING, ele terá sucesso porque a condição de falha não será acionada.

Resumo

Parabéns. Você criou com sucesso um job do Jenkins flexível e robusto.

Neste laboratório, você aprendeu como:

• Criar um job do Jenkins parametrizado usando parâmetros de String e de Escolha (Choice).
• Executar scripts shell como parte de um processo de build.
• Acessar e usar parâmetros de build como variáveis de ambiente dentro de seus scripts.
• Implementar lógica condicional em um script para controlar o resultado do build.
• Usar condições shell e códigos de saída para controlar se um build terá sucesso ou falhará.

Essas habilidades são essenciais para construir pipelines de CI/CD sofisticados que podem se adaptar a diferentes entradas e lidar com erros de forma inteligente. Agora você pode aplicar esses conceitos para automatizar seus próprios fluxos de trabalho de desenvolvimento e implantação.