Tutorial: Criar um pipeline Jenkins usando o GitHub e o Docker

2025-05-08

Importante

Embora muitos serviços do Azure tenham plug-ins Jenkins, a maioria desses plug-ins encerrou o suporte a partir de 29 de fevereiro de 2024. A CLI do Azure é a maneira atualmente recomendada de integrar o Jenkins aos serviços do Azure. Para obter mais informações, consulte o artigo Jenkins plug-ins for Azure.

Para automatizar a fase de compilação e teste do desenvolvimento de aplicativos, você pode usar um pipeline de integração e implantação contínua (CI/CD). Neste tutorial, você cria um pipeline de CI/CD em uma VM do Azure, incluindo como:

Criar uma VM Jenkins
Instalar e configurar o Jenkins
Crie integração de webhook entre o GitHub e o Jenkins
Criar e acionar Jenkins build jobs a partir de commits do GitHub
Criar uma imagem do Docker para seu aplicativo
Verifique se os commits no GitHub geram uma nova imagem Docker e atualizam a aplicação em execução.

Este tutorial usa a CLI no Azure Cloud Shell, que é constantemente atualizado para a versão mais recente. Para abrir o Cloud Shell, selecione Experimentar na parte superior de qualquer bloco de código.

Se optar por instalar e utilizar a CLI localmente, este tutorial exigirá que execute a versão 2.0.30 ou posterior da CLI do Azure. Executar az --version para localizar a versão. Se precisar de instalar ou atualizar, consulte Install Azure CLI.

Criar instância do Jenkins

Em um tutorial anterior sobre Como personalizar uma máquina virtual Linux na primeira inicialização, você aprendeu como automatizar a personalização de VM com cloud-init. Este tutorial usa um arquivo cloud-init para instalar o Jenkins e o Docker em uma VM. O Jenkins é um popular servidor de automação de código aberto que se integra perfeitamente ao Azure para permitir a integração contínua (CI) e a entrega contínua (CD). Para obter mais tutoriais sobre como usar o Jenkins, consulte o Jenkins no hub do Azure.

No shell atual, crie um arquivo chamado cloud-init-jenkins.txt e cole a seguinte configuração. Por exemplo, crie o ficheiro no Cloud Shell, não no seu computador local. Entre sensible-editor cloud-init-jenkins.txt para criar o arquivo e veja uma lista de editores disponíveis. Certifique-se de que o ficheiro de inicialização da cloud é copiado corretamente, especialmente a primeira linha:

#cloud-config
package_upgrade: true
write_files:
  - path: /etc/systemd/system/docker.service.d/docker.conf
    content: |
      [Service]
        ExecStart=
        ExecStart=/usr/bin/dockerd
  - path: /etc/docker/daemon.json
    content: |
      {
        "hosts": ["fd://","tcp://127.0.0.1:2375"]
      }
runcmd:
  - apt install openjdk-8-jre-headless -y
  - wget -q -O - https://pkg.jenkins.io/debian/jenkins-ci.org.key | sudo apt-key add -
  - sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'
  - apt-get update && apt-get install jenkins -y
  - curl -sSL https://get.docker.com/ | sh
  - usermod -aG docker azureuser
  - usermod -aG docker jenkins
  - service jenkins restart

Antes de poder criar uma VM, tem de criar um grupo de recursos com az group create. O exemplo a seguir cria um grupo de recursos chamado myResourceGroupJenkins no local eastus :

az group create --name myResourceGroupJenkins --location eastus

Agora crie uma VM com az vm create. Utilize o parâmetro --custom-data para passar o seu ficheiro de configuração do cloud-init. Forneça o caminho completo para cloud-init-jenkins.txt se você salvou o arquivo fora do diretório de trabalho atual.

az vm create --resource-group myResourceGroupJenkins \
    --name myVM \
    --image UbuntuLTS \
    --admin-username azureuser \
    --generate-ssh-keys \
    --custom-data cloud-init-jenkins.txt

Leva alguns minutos para que a VM seja criada e configurada.

Para permitir que o tráfego da Web alcance sua VM, use az vm open-port para abrir a porta 8080 para o tráfego Jenkins e a porta 1337 para o aplicativo Node.js usado para executar um aplicativo de exemplo:

az vm open-port --resource-group myResourceGroupJenkins --name myVM --port 8080 --priority 1001
az vm open-port --resource-group myResourceGroupJenkins --name myVM --port 1337 --priority 1002

Configurar o Jenkins

Para acessar sua instância Jenkins, obtenha o endereço IP público de sua VM:

az vm show --resource-group myResourceGroupJenkins --name myVM -d --query [publicIps] --o tsv

Por motivos de segurança, você precisa inserir a senha inicial de administrador armazenada em um arquivo de texto em sua VM para iniciar a instalação do Jenkins. Use o endereço IP público obtido na etapa anterior para SSH para sua VM:

ssh azureuser@<publicIps>

Verifique se Jenkins está em execução usando o service comando:

$ service jenkins status
● jenkins.service - LSB: Start Jenkins at boot time
   Loaded: loaded (/etc/init.d/jenkins; generated)
   Active: active (exited) since Tue 2019-02-12 16:16:11 UTC; 55s ago
     Docs: man:systemd-sysv-generator(8)
    Tasks: 0 (limit: 4103)
   CGroup: /system.slice/jenkins.service

Feb 12 16:16:10 myVM systemd[1]: Starting LSB: Start Jenkins at boot time...
...

Veja o initialAdminPassword para a sua instalação do Jenkins e copie-o:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Se o arquivo ainda não estiver disponível, aguarde mais alguns minutos para que o cloud-init conclua a instalação do Jenkins e do Docker.

Agora abra um navegador da Web e vá para http://<publicIps>:8080. Conclua a configuração inicial do Jenkins da seguinte maneira:

Escolha Selecionar plug-ins para instalar
Procure por GitHub na caixa de texto na parte superior. Marque a caixa para GitHub e selecione Instalar
Crie o primeiro usuário administrador. Introduza um nome de utilizador, como admin, e, em seguida, forneça a sua própria palavra-passe segura. Por fim, digite um nome completo e um endereço de e-mail.
Selecione Salvar e Concluir
Quando Jenkins estiver pronto, selecione Começar a usar Jenkins
- Se o seu navegador da Web exibir uma página em branco quando você começar a usar o Jenkins, reinicie o serviço Jenkins. Na sessão SSH, digite sudo service jenkins restarte, em seguida, atualize o navegador da Web.
Se necessário, inicie sessão no Jenkins com o nome de utilizador e palavra-passe que criou.

Criar webhook do GitHub

Para configurar a integração com o GitHub, abra o aplicativo de exemploNode.js Hello World no repositório de exemplos do Azure. Para bifurcar o repositório para sua própria conta do GitHub, selecione o botão Fork no canto superior direito.

Crie um webhook dentro do fork que criou:

Selecione Configurações e, em seguida, selecione Webhooks no lado esquerdo.
Escolha Adicionar webhook e, em seguida, insira Jenkins na caixa de filtro.
Para o URL de Payload, introduza http://<publicIps>:8080/github-webhook/. Certifique-se de incluir a barra final.
Em Tipo de conteúdo, selecione application/x-www-form-urlencoded.
Em Quais eventos você gostaria de acionar esse webhook?, selecione Apenas o evento push.
Defina Ativo como verificado.
Clique em Adicionar webhook.

Adicione o webhook do GitHub ao seu repositório bifurcado

Criar tarefa Jenkins

Para que o Jenkins responda a um evento no GitHub, como fazer commit de código, crie uma tarefa Jenkins. Utilize os URLs do teu próprio fork do GitHub.

No seu site Jenkins, selecione Criar novos trabalhos na página inicial:

Digite HelloWorld como nome do trabalho. Escolha Projeto Freestyle e, em seguida, selecione OK.
Na seção Geral , selecione o projeto GitHub e insira sua URL de repositório bifurcada, como https://github.com/cynthn/nodejs-docs-hello-world
Na seção Gerenciamento de código-fonte, selecione Git e insira o URL de seu repositório derivado .git, tal como https://github.com/cynthn/nodejs-docs-hello-world.git.
Na seção Build Triggers, selecione o GitHub hook trigger para sondagem do Git SCM.
Na seção Build , escolha Add build step. Selecione Executar shell e, em seguida, digite echo "Test" na janela de comando.
Selecione Salvar na parte inferior da janela de trabalhos.

Testar a integração com o GitHub

Para testar a integração do GitHub com o Jenkins, realize um commit na sua fork.

De volta à interface do usuário da Web do GitHub, selecione seu repositório bifurcado e, em seguida, selecione o arquivo index.js . Selecione o ícone de lápis para editar este arquivo para que a linha 6 leia:

response.end("Hello World!");

Para confirmar as alterações, selecione o botão Confirmar alterações na parte inferior.

No Jenkins, uma nova compilação começa na seção Histórico de construção no canto inferior esquerdo da página de trabalho. Escolha o link do número de compilação e selecione Saída do console no lado esquerdo. Você pode visualizar as etapas que Jenkins executa quando seu código é extraído do GitHub e a ação de compilação envia a mensagem Test para o console. Cada vez que uma confirmação é feita no GitHub, o webhook entra em contato com Jenkins e aciona uma nova compilação dessa maneira.

Definir imagem de construção do Docker

Para ver o aplicativo Node.js em execução com base em suas confirmações do GitHub, vamos criar uma imagem do Docker para executar o aplicativo. A imagem é criada a partir de um Dockerfile que define como configurar o contêiner que executa o aplicativo.

A partir da ligação SSH para a sua VM, mude para o diretório de espaço de trabalho do Jenkins com o nome do trabalho que criou numa etapa anterior. Neste exemplo, isto foi chamado de HelloWorld.

cd /var/lib/jenkins/workspace/HelloWorld

Crie um arquivo neste diretório de espaço de trabalho com sudo sensible-editor Dockerfile e cole o seguinte conteúdo. Certifique-se de que todo o Dockerfile é copiado corretamente, especialmente a primeira linha:

FROM node:alpine

EXPOSE 1337

WORKDIR /var/www
COPY package.json /var/www/
RUN npm install
COPY index.js /var/www/

Este Dockerfile utiliza a imagem base Node.js com Alpine Linux, expõe a porta 1337 na qual corre a aplicação Hello World, depois copia os ficheiros da aplicação e inicializa a aplicação.

Criar regras de construção do Jenkins

Em uma etapa anterior, você criou uma regra de compilação básica do Jenkins que envia uma mensagem para o console. Vamos criar a etapa de compilação para usar nosso Dockerfile e executar o aplicativo.

De volta à sua instância do Jenkins, selecione o trabalho que você criou em uma etapa anterior. Selecione Configurar no lado esquerdo e role para baixo até a seção Compilar :

Remova a sua etapa de compilação echo "Test" existente. Selecione a cruz vermelha no canto superior direito da caixa de etapa de construção existente.
Escolha Adicionar etapa de compilação e, em seguida, selecione Executar shell

Na caixa Comando , digite os seguintes comandos do Docker e selecione Salvar:

docker build --tag helloworld:$BUILD_NUMBER .
docker stop helloworld && docker rm helloworld
docker run --name helloworld -p 1337:1337 helloworld:$BUILD_NUMBER node /var/www/index.js &

As etapas de construção do Docker criam uma imagem e a marcam com o número de compilação do Jenkins para que você possa manter um histórico de imagens. Todos os contêineres existentes que executam o aplicativo são interrompidos e, em seguida, removidos. Um novo contêiner é então iniciado usando a imagem e executa seu aplicativo Node.js com base nas confirmações mais recentes no GitHub.

Teste o seu pipeline

Para ver todo o pipeline em ação, edite o arquivo index.js no repositório GitHub bifurcado e selecione Confirmar alteração. Um novo trabalho começa em Jenkins com base no webhook para o GitHub. Leva alguns segundos para criar a imagem do Docker e iniciar seu aplicativo em um novo contêiner.

Se necessário, obtenha o endereço IP público da sua VM novamente:

az vm show --resource-group myResourceGroupJenkins --name myVM -d --query [publicIps] --o tsv

Abra um navegador da Web e digite http://<publicIps>:1337. A sua aplicação Node.js é exibida e reflete os commits mais recentes no seu fork no GitHub da seguinte maneira:

Executar aplicação Node.js

Agora faça outra edição no arquivo index.js no GitHub e confirme a alteração. Aguarde alguns segundos até que o trabalho seja concluído no Jenkins e, em seguida, atualize o navegador da Web para ver a versão atualizada do seu aplicativo em execução em um novo contêiner da seguinte maneira:

Executar a aplicação Node.js após outro commit no GitHub

Próximos passos

Neste tutorial, você configurou o GitHub para executar um trabalho de compilação do Jenkins em cada confirmação de código e, em seguida, implantar um contêiner do Docker para testar seu aplicativo. Você aprendeu a:

Criar uma VM Jenkins
Instalar e configurar o Jenkins
Crie integração de webhook entre o GitHub e o Jenkins
Criar e acionar Jenkins build jobs a partir de commits do GitHub
Criar uma imagem do Docker para seu aplicativo
Verifique se os commits no GitHub geram uma nova imagem Docker e atualizam a aplicação em execução.

Avance para o próximo tutorial para saber mais sobre como integrar o Jenkins aos Serviços de DevOps do Azure.

Implantar aplicativos com o Jenkins e os Serviços de DevOps do Azure