Houve momentos em que criávamos trabalhos Jenkins apenas usando a interface do usuário. Posteriormente, a ideia de pipeline como código foi proposta para lidar com a crescente complexidade dos trabalhos de compilação e implantação. No Jenkins 2.0, a equipe do Jenkins introduziu o Jenkinsfile para alcançar o pipeline como código. Se você deseja criar um pipeline Jenkins automatizado baseado em solicitações de pull ou em branch, o pipeline multibranch do Jenkins é o caminho a seguir.Integração Contínua e Entrega Contínua
Como o pipeline multibranch do Jenkins é totalmente baseado em git como código, você pode construir seus fluxos de trabalho de CI/CD. O Pipeline como Código (PaaC) facilita a aplicação das vantagens da automação e da portabilidade em nuvem em seus testes Selenium. Você pode usar o modelo de pipeline multibranch para construir, testar, implantar, monitorar, relatar e gerenciar seus testes Selenium de forma rápida e confiável, e muito mais. Neste tutorial do Jenkins, vamos ver como criar um pipeline multibranch do Jenkins e os conceitos-chave envolvidos na configuração de um pipeline multibranch do Jenkins para testes automatizados de Selenium.
Vamos começar.
O que é o Pipeline Multibranch do Jenkins?
De acordo com a documentação oficial, o tipo de trabalho de pipeline multibranch permite definir um trabalho em que, a partir de um único repositório git, o Jenkins detectará várias ramificações e criará trabalhos aninhados quando encontrar um Jenkinsfile.
A partir da definição acima, podemos entender que o Jenkins pode escanear o repositório Git em busca do Jenkinsfile e criar tarefas automaticamente. Tudo o que precisa de nós são os detalhes do Repositório Git. Neste artigo, vamos utilizar um repositório GitHub de exemplo. Nosso repositório GitHub de exemplo contém um projeto de exemplo Spring Boot, que pode ser implantado no Tomcat.
Na pasta raiz do projeto, temos o Jenkinsfile. Utilizamos a sintaxe de pipeline declarativo do Jenkins para criar este Jenkinsfile. Se você é novo no pipeline declarativo do Jenkins, por favor leia nosso artigo detalhado aqui.
Jenkinsfile de exemplo
pipeline {
agent any
stages {
stage('Build Code') {
steps {
sh """
echo "Building Artifact"
"""
}
}
stage('Deploy Code') {
steps {
sh """
echo "Deploying Code"
"""
}
}
}
}Criamos dois estágios “Compilar Código” e “Implantar Código” em nosso Jenkinsfile, cada um deles configurado para imprimir mensagens apropriadas. Agora, temos o repositório Git com o Jenkinsfile pronto.
Vamos criar um pipeline multibranch no servidor Jenkins.
Pipeline do Jenkins vs Pipeline Multibranch
O pipeline do Jenkins é a nova sensação, mas não é para todos. E os pipelines multibranch ainda são incríveis. Nesta seção do tutorial de pipeline multibranch do Jenkins, vamos entender os casos de uso ideais para o pipeline do Jenkins e o pipeline multibranch através desta comparação de pipeline do Jenkins vs pipeline multibranch.
Jenkins pipeline é um sistema de configuração de trabalhos que permite configurar um pipeline de trabalhos, que serão executados automaticamente em seu nome. Um pipeline do Jenkins pode ter várias etapas e cada etapa será executada por um único agente, todos rodando em uma única máquina ou em várias máquinas. Normalmente, um pipeline é criado para um ramo específico do código-fonte. Ao criar um novo trabalho, você verá uma opção para selecionar o repositório de código-fonte e o ramo. Você também pode criar um pipeline novo para um novo projeto ou uma nova funcionalidade de um projeto existente.
O pipeline do Jenkins permite que você tenha um Jenkinsfile flexível com etapas para sua compilação. Assim, você pode ter uma etapa inicial onde executa a verificação de lint, testes, etc., e depois etapas separadas para criar artefatos ou implantá-los. Isso é muito útil quando você deseja fazer várias coisas em seu pipeline.
E se você tiver apenas uma coisa a fazer? Ou se todas as coisas que você quer fazer são diferentes dependendo de alguma configuração? Faz sentido usar o pipeline do Jenkins aqui?
O pipeline multiramo é uma abordagem alternativa que pode ser mais adequada nestes casos. O pipeline multiramo permite que você divida tarefas em ramos e as junte posteriormente. Isso é muito semelhante ao modo como funciona a ramificação no Git.
A multibranch pipeline is a pipeline that has multiple branches. The main advantage of using a multibranch pipeline is to build and deploy multiple branches from a single repository. Having a multibranch pipeline also allows you to have different environments for different branches. However, it is not recommended to use a multibranch pipeline if you do not have a standard branching and CI/CD strategy.
Agora, já que você viu a comparação entre o pipeline do Jenkins e o pipeline multiramo, vamos passar pelos passos para criar um pipeline multiramo do Jenkins.
Criando um Pipeline Multiramo do Jenkins
Passo 1
Abra a página inicial do Jenkins (http://localhost:8080 localmente) e clique em “Novo Item” no menu à esquerda.
Passo 2
Insira o nome do trabalho Jenkins, escolha o estilo como “pipeline multibranch,” e clique em “OK.”
Passo 3
Na página “Configure,” precisamos configurar apenas uma coisa: A Fonte do Repositório Git.
Role para baixo até a seção “Branch Sources” e clique no menu suspenso “Add Source.”
Escolha “GitHub” como fonte porque nosso repositório de amostra no GitHub está hospedado lá.
Passo 4
Insira o URL HTTPS do Repositório como https://github.com/iamvickyav/spring-boot-h2-war-tomcat.git e clique em “Validate.”
Como nosso repositório no GitHub é hospedado como um repositório público, não precisamos configurar credenciais para acessá-lo. Para repositórios empresariais/privados, podemos precisar de credenciais para acessá-los.
A mensagem “Credenciais ok” representa que a conexão entre o servidor Jenkins e o repositório Git foi bem-sucedida.
Passo 5
Deixe as demais seções de configuração assim por enquanto e clique no botão “Save” no final.
Ao salvar, o Jenkins executará automaticamente os seguintes passos:
Escanear Etapa do Repositório
- Escaneie o repositório Git que configuramos.
- Procure a lista de branches disponíveis no repositório Git.
- Selecione os branches que possuem Jenkinsfile.
Etapa de Execução de Build
- Execute a build para cada uma das branches encontradas no passo anterior com os passos mencionados no Jenkinsfile.
A partir da seção “Verificar Log do Repositório“, podemos entender o que aconteceu durante o passo de verificar o repositório.
Como só temos uma branch mestra em nosso repositório Git, o Log de Verificação do Repositório diz “Processadas 1 branch.”
Após a verificação ser concluída, o Jenkins criará e executará um trabalho de build para cada branch processada separadamente.
No nosso caso, tínhamos apenas uma branch chamada master. Portanto, o build será executado apenas para a nossa branch master. Podemos verificar isso clicando em “Status” no menu lateral.
Podemos ver um trabalho de build criado para a branch master na seção de status.
Clique no nome da branch para ver o log e o status do trabalho de build.
“Visão das Etapas” fornece uma representação visual de quanto tempo cada etapa levou para ser executada e o status do trabalho de build.
Acessar Logs de Execução do Trabalho de Build
Passo 1
Clique no “Número do Build” na seção “Histórico do Build”.
Passo 2
Em seguida, escolha o “Output da Console” no menu lateral para ver os logs.
O que acontece se tivermos mais de uma branch em nosso repositório Git? Vamos verificar isso agora.
No repositório Git, uma nova branch chamada “desenvolvimento” é criada.
Para diferenciar a compilação da “branch desenvolver“, fizemos pequenas alterações nos comandos echo no Jenkinsfile.
Jenkinsfile na Branch Master
pipeline {
agent any
stages {
stage('Build Code') {
steps {
sh """
echo "Building Artifact"
"""
}
}
stage('Deploy Code') {
steps {
sh """
echo "Deploying Code"
"""
}
}
}
}Jenkinsfile na Branch Desenvolvimento
pipeline {
agent any
stages {
stage('Build Code') {
steps {
sh """
echo "Building Artifact from Develop Branch"
"""
}
}
stage('Deploy Code') {
steps {
sh """
echo "Deploying Code from Develop Branch"
"""
}
}
}
}Agora, temos dois Jenkinsfile em duas branches diferentes. Vamos reexecutar a varredura do repositório no Jenkins para ver o comportamento.
Podemos ver que a nova branch (branch de desenvolvimento) foi detectada por Jenkins. Portanto, um novo trabalho foi criado separadamente para a branch de desenvolvimento.
Ao clicar em “desenvolver”, podemos ver o log do trabalho de compilação da branch de desenvolvimento.
No exemplo anterior, mantivemos conteúdos diferentes para o Jenkinsfile nas branches mestre e desenvolvimento. Mas não é assim que fazemos em aplicativos do mundo real. Nós aproveitamos os blocos when dentro do bloco stage para verificar a branch.
Aqui está um exemplo com etapas combinadas para as branches mestre e desenvolvimento. Este mesmo conteúdo será colocado em ambos os Jenkinsfiles das branches mestre e desenvolvimento.
pipeline {
agent any
stages {
stage('Master Branch Deploy Code') {
when {
branch 'master'
}
steps {
sh """
echo "Building Artifact from Master branch"
"""
sh """
echo "Deploying Code from Master branch"
"""
}
}
stage('Develop Branch Deploy Code') {
when {
branch 'develop'
}
steps {
sh """
echo "Building Artifact from Develop branch"
"""
sh """
echo "Deploying Code from Develop branch"
"""
}
}
}
}Etapa 3
Clique em “Varrer Repositório” no menu à esquerda para que o Jenkins detecte as novas alterações do repositório Git.
Até agora, você deve ter notado que estamos usando a varredura do repositório sempre que queremos que o Jenkins detecte as alterações do repositório.
Que tal automatizar este passo?
Disparador Periódico para Varredura de Pipeline Multibranch do Jenkins
Etapa 1
Clique em “Configurar” no menu à esquerda.
Etapa 2
Role para baixo até a seção “Scan Repository Triggers” e ative a caixa de seleção “Periodically if not otherwise run” e escolha o intervalo de tempo para a varredura ser executada periodicamente (dois minutos em nosso exemplo).
Passo 3
Clique no botão “Save”.
A partir de agora, o Jenkins varrerá o repositório a cada dois minutos. Se um novo commit for encontrado em qualquer ramo, o Jenkins executará um novo trabalho de build para esse ramo específico usando o Jenkinsfile.
Abaixo está o “Scan Repository Log”, que mostra claramente a varredura disparada a cada dois minutos.
Casos de Uso em Tempo Real para Pipeline Multiramo do Jenkins
Abaixo estão alguns cenários onde a pipeline multiramo do Jenkins pode ser útil:
- Qualquer novo commit na branch mestra deve ser implantado automaticamente no servidor.
- Se um desenvolvedor tentar abrir um Pull Request (PR) para desenvolver uma branch, então:
- O código deve ser construído com sucesso sem erro de compilação.
- O código deve ter pelo menos 80% de cobertura de teste.
- O código deve passar no teste de qualidade do código SONAR.
- Se os desenvolvedores tentarem enviar o código para uma branch que não seja master ou develop, o código deve compilar com sucesso. Se não, envie um email de alerta.
Aqui está um exemplo de Jenkinsfile cobrindo alguns dos casos de uso acima:
pipeline {
agent any
tools {
maven 'MAVEN_PATH'
jdk 'jdk8'
}
stages {
stage("Tools initialization") {
steps {
sh "mvn --version"
sh "java -version"
}
}
stage("Checkout Code") {
steps {
checkout scm
}
}
stage("Check Code Health") {
when {
not {
anyOf {
branch 'master';
branch 'develop'
}
}
}
steps {
sh "mvn clean compile"
}
}
stage("Run Test cases") {
when {
branch 'develop';
}
steps {
sh "mvn clean test"
}
}
stage("Check Code coverage") {
when {
branch 'develop'
}
steps {
jacoco(
execPattern: '**/target/**.exec',
classPattern: '**/target/classes',
sourcePattern: '**/src',
inclusionPattern: 'com/iamvickyav/**',
changeBuildStatus: true,
minimumInstructionCoverage: '30',
maximumInstructionCoverage: '80')
}
}
stage("Build and Deploy Code") {
when {
branch 'master'
}
steps {
sh "mvn tomcat7:deploy"
}
}
}
}Cometemos este novo Jenkinsfile nas branches master e develop, para que possa ser detectado pelo Jenkins multibranch na próxima varredura do repositório.
Teste de Automação Selenium com Pipeline Multibranch Jenkins
Vamos considerar que estamos escrevendo casos de teste de automação para um site. Sempre que um novo caso de teste é cometido em uma branch, queremos executá-los e garantir que estão sendo executados conforme o esperado.
Executar casos de teste de automação em todas as combinações de navegador e sistema operacional é um pesadelo para qualquer desenvolvedor. É aí que a poderosa infraestrutura de teste de automação da LambdaTest pode ser útil.
Usando a grade Selenium da LambdaTest, você pode maximizar a cobertura de navegadores.
Nesta seção, veremos como aproveitar a infraestrutura de teste da LambdaTest com a pipeline multibranch do Jenkins. Para demonstrar, hospedamos um exemplo de aplicativo Todo aqui – LambdaTest ToDo App. Casos de teste de automação escritos com Cucumber são cometidos no repositório de amostra.
Do Jenkins, queremos executar esses casos de teste no plataforma LambdaTest. Executar casos de teste na LambdaTest requer nome de usuário e accessToken. Registre-se na plataforma LambdaTest gratuitamente para obter suas credenciais.
Configuração de Variável de Ambiente
Quando o caso de teste é executado, ele procurará pelo nome de usuário (LT_USERNAME) e senha (LT_ACCESS_KEY) da LambdaTest nas variáveis de ambiente. Portanto, precisamos configurá-los com antecedência.
Para evitar armazená-los com o código-fonte, configuramos-os como segredos no Jenkins e carregamos variáveis de ambiente a partir deles:
environment {
LAMBDATEST_CRED = credentials('Lambda-Test-Credentials-For-multibranch')
LT_USERNAME = "$LAMBDATEST_CRED_USR"
LT_ACCESS_KEY = "$LAMBDATEST_CRED_PSW"
}Aqui está nosso Jenkinsfile final:
pipeline {
agent any
tools {
maven 'MAVEN_PATH'
jdk 'jdk8'
}
stages {
stage("Tools initialization") {
steps {
sh "mvn --version"
sh "java -version"
}
}
stage("Checkout Code") {
steps {
checkout scm
}
}
stage("Check Code Health") {
when {
not {
anyOf {
branch 'master';
branch 'develop'
}
}
}
steps {
sh "mvn clean compile"
}
}
stage("Run Test cases in LambdaTest") {
when {
branch 'develop';
}
environment {
LAMBDATEST_CRED = credentials('Lambda-Test-Credentials-For-multibranch')
LT_USERNAME = "$LAMBDATEST_CRED_USR"
LT_ACCESS_KEY = "$LAMBDATEST_CRED_PSW"
}
steps {
sh "mvn test"
}
}
}
}Agora, criaremos um novo “Trabalho” no Jenkins como uma pipeline multibranch seguindo os passos mencionados nas seções anteriores. Vamos apontar para o repositório de amostra.
Uma vez que a compilação seja executada com sucesso, visite o painel de automação da LambdaTest para obter os logs de teste.
Conclusão
Com isso, aprendemos a criar uma pipeline multibranch no Jenkins, como configurar um repositório git nele, diferentes etapas de compilação para diferentes branches, usando a varredura periódica automática do repositório pelo Jenkins e aproveitando a poderosa infraestrutura de teste de automação da LambdaTest para automatizar nossas compilações CI/CD. Espero que tenha achado este artigo útil. Por favor, compartilhe seu feedback na seção de comentários.
Source:
https://dzone.com/articles/how-to-create-jenkins-multibranch-pipeline