Compartilhar via

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

Importante

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

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

  • Criar uma VM Jenkins
  • Instalar e configurar o Jenkins
  • Criar integração de webhook entre o GitHub e o Jenkins
  • Criar e iniciar tarefas de build do Jenkins a partir de commits do GitHub
  • Criar uma imagem do Docker para seu aplicativo
  • Verificar se commits no GitHub constroem uma nova imagem do Docker e atualizam o aplicativo em execução.

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

Se você optar por instalar e usar a CLI localmente, este tutorial exigirá que você execute a CLI do Azure versão 2.0.30 ou posterior. Execute az --version para encontrar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.

Criar instância do Jenkins

Em um tutorial anterior sobre como personalizar uma máquina virtual linux na primeira inicialização, você aprendeu a automatizar a personalização da 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 software livre que se integra perfeitamente ao Azure para habilitar a CI (integração contínua) e o CD (entrega contínua). 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 configuração a seguir. Por exemplo, crie o arquivo no Cloud Shell e não em seu computador local. Insira sensible-editor cloud-init-jenkins.txt para criar o arquivo e veja uma lista de editores disponíveis. Certifique-se de que o arquivo de inicialização de nuvem inteiro seja 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 criar uma máquina virtual, crie um grupo de recursos com o 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 --custom-data parâmetro para passar o arquivo de configuração 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 que é 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 Jenkins

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

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

Para fins de segurança, você precisa inserir a senha de administrador inicial 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 o 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...
...

Exiba o initialAdminPassword para 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 instalação
  • Pesquise o GitHub na caixa de texto na parte superior. Marque a caixa do GitHub e selecione Instalar
  • Crie o primeiro usuário administrador. Insira um nome de usuário, como o administrador, e forneça sua própria senha segura. Por fim, digite um nome completo e um endereço de email.
  • Selecione Salvar e Concluir
  • Depois que o Jenkins estiver pronto, selecione Iniciar usando o Jenkins
    • Se o 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 atualize o navegador da Web.
  • Se necessário, faça logon no Jenkins com o nome de usuário e a senha que você 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 Bifurcação no canto superior direito.

Crie um webhook dentro do fork que você criou:

  • Selecione Configurações e selecione Webhooks no lado esquerdo.
  • Escolha Adicionar webhook e, em seguida, insira Jenkins na caixa de filtro.
  • Para o Payload URL, insira http://<publicIps>:8080/github-webhook/. Certifique-se de incluir a parte à direita/
  • Para o tipo de conteúdo, selecione application/x-www-form-urlencoded.
  • Para quais eventos você deseja disparar esse webhook?, selecione Apenas o evento push.
  • Definir Ativo como verificado.
  • Clique em Adicionar webhook.

Adicionar webhook do GitHub ao repositório bifurcado

Criar trabalho do Jenkins

Para que o Jenkins responda a um evento no GitHub, como a confirmação de código, crie um trabalho do Jenkins. Use as URLs para sua própria bifurcação do GitHub.

No site do Jenkins, selecione Criar novos trabalhos na home page:

  • Insira HelloWorld como nome do trabalho. Escolha o projeto Freestyle e selecione OK.
  • Na seção Geral , selecione o projeto do GitHub e insira a URL do repositório bifurcado, como https://github.com/cynthn/nodejs-docs-hello-world
  • Na seção Gerenciamento do código-fonte , selecione Git, insira a URL .git do repositório bifurcado, como https://github.com/cynthn/nodejs-docs-hello-world.git
  • Na seção Compilar Gatilhos , selecione o gatilho de gancho do GitHub para sondagem GITscm.
  • Na seção Compilar , escolha Adicionar etapa de build. Selecione Executar shell e, em seguida, insira echo "Test" na janela de comando.
  • Selecione Salvar na parte inferior da janela de trabalhos.

Testar a integração do GitHub

Para testar a integração do GitHub com o Jenkins, faça um commit de uma alteração no fork.

De volta à interface do usuário da web do GitHub, selecione o seu repositório forkado 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 suas alterações, selecione o botão Confirmar alterações na parte inferior.

No Jenkins, um novo build começa na seção Build history do canto inferior esquerdo da página do trabalho. Escolha o link de número de build e selecione a saída do console no lado esquerdo. Você pode exibir as etapas que o Jenkins executa à medida que seu código é extraído do GitHub e a ação de build gera a mensagem Test para o console. Sempre que uma confirmação é feita no GitHub, o webhook alcança o Jenkins e dispara um novo build dessa forma.

Definir imagem de build do Docker

Para ver o aplicativo Node.js funcionando com seus commits 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.

Na conexão SSH com sua VM, mude para o diretório do workspace do Jenkins, nomeado conforme o trabalho que você criou em uma etapa anterior. Neste exemplo, que se chamava HelloWorld.

cd /var/lib/jenkins/workspace/HelloWorld

Crie um arquivo neste diretório de workspace com sudo sensible-editor Dockerfile e cole o conteúdo a seguir. Verifique se todo o Dockerfile foi 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/

Esse Dockerfile utiliza a imagem base Node.js com Alpine Linux, expõe a porta 1337 na qual o aplicativo Hello World é executado, então copia os arquivos do aplicativo e inicializa-o.

Criar regras de build do Jenkins

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

De volta à 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 Build:

  • Remova a echo "Test" etapa de build existente. Selecione a cruz vermelha no canto superior direito da caixa de etapa de build existente.

  • Escolha Adicionar etapa de build e, em seguida, selecione Executar shell

  • Na caixa Comando , insira 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 build do Docker criam uma imagem e a marcam com o número de build 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 removidos. Em seguida, um novo contêiner é iniciado usando a imagem e executa seu aplicativo Node.js com base nas confirmações mais recentes no GitHub.

Testar seu pipeline

Para ver todo o pipeline em ação, edite o arquivo index.js no repositório do GitHub que você bifurcou e selecione Fazer commit. Um novo trabalho começa no Jenkins com base no webhook do 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 VM novamente:

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

Abra um navegador da Web e insira http://<publicIps>:1337. Seu aplicativo Node.js é exibido e reflete os commits mais recentes em sua bifurcação do GitHub, como segue:

Aplicativo Node.js em execução

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

Executando Node.js aplicativo após outro commit do GitHub

Próximas etapas

Neste tutorial, você configurou o GitHub para executar um trabalho de build 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
  • Criar integração de webhook entre o GitHub e o Jenkins
  • Criar e iniciar tarefas de build do Jenkins a partir de commits do GitHub
  • Criar uma imagem do Docker para seu aplicativo
  • Verificar se commits no GitHub constroem uma nova imagem do Docker e atualizam o aplicativo em execução.

Avance para o próximo tutorial para saber mais sobre como integrar o Jenkins ao Azure DevOps Services.

Implantar aplicativos com o Jenkins e o Azure DevOps Services