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 abordar a crescente complexidade com trabalhos de build 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 automatizado de solicitação de pull baseado ou baseado em branch para Integração Contínua e Entrega Contínua no Jenkins, o pipeline multibranch do Jenkins é o caminho a seguir.
Como o pipeline multibranch do Jenkins é totalmente baseado em git e 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 para 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 dar uma olhada em 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 é Pipeline Multibranch do Jenkins?
De acordo com a documentação oficial, um tipo de trabalho de pipeline multibranch permite que você defina um trabalho a partir de um único repositório git, no qual o Jenkins detectará várias分支 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 para o 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.
Exemplo de Jenkinsfile
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 vs Pipeline Multibranch no Jenkins
O pipeline do Jenkins é a grande novidade, 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 vs pipeline multibranch do Jenkins.
O pipeline Jenkins é um sistema de configuração de trabalho que permite configurar um pipeline de trabalhos, que serão executados automaticamente em seu nome. Um pipeline Jenkins pode ter múltiplas etapas e cada etapa será executada por um único agente, tudo rodando em uma única máquina ou em múltiplas 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 fresco para um novo projeto ou nova funcionalidade de um projeto existente.
O pipeline Jenkins permite que você tenha um Jenkinsfile flexível com etapas para sua compilação. Assim, você pode ter uma etapa inicial onde executa verificação de estilo, testes, etc., e etapas separadas para construir 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ê deseja fazer são diferentes dependendo de alguma configuração? Faz sentido usar o pipeline Jenkins aqui?
O pipeline multiramo é uma abordagem alternativa que pode ser mais adequada nesses casos. O pipeline multiramo permite que você divida tarefas em ramos e as junte posteriormente. Isso é muito semelhante ao modo como o branching do Git funciona.
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 Jenkins e o pipeline multiramo, vamos passar pelos passos para criar um pipeline multiramo Jenkins.
Criando um Pipeline Multiramo Jenkins
Passo 1
Abra a página inicial do Jenkins (http://localhost:8080 localmente) e clique em “Novo Item” no menu à esquerda.
Passo 2
Digite nome do trabalho do Jenkins, selecione 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, pois nosso repositório de amostra do 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 do 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 o restante das seções de configuração como estão por enquanto e clique no botão “Save” no final.
Ao salvar, o Jenkins executará automaticamente os seguintes passos:
Escanear Etapa do Repositório
- Escanear o repositório Git que configuramos.
- Procurar a lista de branches disponíveis no repositório Git.
- Selecionar 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 “1 branch foi processado.”
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 de Builds”.
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 “rama desenvolvimento“, fizemos pequenas alterações nos comandos echo no Jenkinsfile.
Jenkinsfile na Rota Principal
pipeline {
agent any
stages {
stage('Build Code') {
steps {
sh """
echo "Building Artifact"
"""
}
}
stage('Deploy Code') {
steps {
sh """
echo "Deploying Code"
"""
}
}
}
}Jenkinsfile na Rota de 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 Jenkinsfiles em duas ramificações diferentes. Vamos reexecutar a varredura do repositório no Jenkins para ver o comportamento.
Podemos ver que a nova branch (rama de desenvolvimento) foi detectada por Jenkins. Portanto, um novo trabalho foi criado separadamente para a rama de desenvolvimento.
Ao clicar em “desenvolvimento“, podemos ver o log do trabalho de compilação da rama de desenvolvimento.
No exemplo anterior, mantivemos conteúdos diferentes para o Jenkinsfile nas ramas principal e de desenvolvimento. Mas não é assim que fazemos em aplicativos do mundo real. Utilizamos os blocos when dentro do bloco stage para verificar a rama.
Aqui está um exemplo com etapas combinadas para as ramas principal e de desenvolvimento. Este mesmo conteúdo será colocado em ambos os Jenkinsfiles das ramas principal e de 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 Jenkins detecte as novas alterações do repositório Git.
A esta altura, você deve ter notado que estamos usando a varredura do repositório sempre que queremos que Jenkins detecte as alterações do repositório.
Que tal automatizar este passo?
Gatilho periódico para varredura de Pipeline Multirrama no Jenkins
Etapa 1
Clique em “Configurar” no menu à esquerda.
Etapa 2
Role para a seção “Scan Repository Triggers” e ative a caixa de seleção “Periodically if not otherwise run”, escolhendo 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 branch, o Jenkins executará um novo trabalho de build para esse branch 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 o Pipeline Multibranch do Jenkins
Aqui estão alguns cenários em que o pipeline multibranch do Jenkins pode ser útil:
- Qualquer novo commit na branch mestra deve ser implantado automaticamente no servidor.
- Se um desenvolvedor tentar abrir uma Pull Request (PR) para desenvolver uma branch, então:
- O código deve ser construído com sucesso sem erros 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 código para uma branch que não seja a mestra ou desenvolvimento, 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 Automatizado de Selenium com Pipeline Multibranch do Jenkins
Vamos considerar que estamos escrevendo casos de teste automatizados para um site. Sempre que um novo caso de teste é commitado em uma branch, queremos executá-los e garantir que estejam funcionando conforme o esperado.
Executar casos de teste automatizados em todas as combinações de navegador e sistema operacional é um pesadelo para qualquer desenvolvedor. É aí que a poderosa infraestrutura de teste automatizado 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 o pipeline multibranch do Jenkins. Para demonstrar, hospedamos um aplicativo de exemplo Todo aqui – LambdaTest ToDo App. Casos de teste automatizados escritos com Cucumber foram commitados no repositório de exemplo.
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 da Variável de Ambiente
Quando o caso de teste é executado, ele buscará o nome de usuário (LT_USERNAME) e a 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, os configuramos como segredos no Jenkins e carregamos as 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 um 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 do LambdaTest para obter os logs dos testes.
Conclusão
Com isso, aprendemos a criar um 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 testes de automação do 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