Jenkins: Pipeline as Code com Vagrant e Docker

Hoje eu terminei de escrever o capitulo 10 do meu livro e o tema foi Pipelines, no livro tem um pouco mais de teoria mas o objetivo aqui é a prática, então vamos lá.

Nesse repositório:

https://github.com/AlissonMMenezes/Chapter10
Tem todos os arquivos que eu vou usar nesse post.

Resumindo o que será feito, eu vou criar uma máquina virtual utilizando Vagrant, que vai ser usada como servidor de Docker e em cima do Docker eu vou rodar um container com Jenkins que vai executar todos os passos da pipeline.

Caso você não saiba nada de Vagrant, eu tenho esse post aqui: http://alissonmachado.com.br/vagrant-ambiente-de-desenvolvimento-agil/
Caso você não saiba nada de Docker, eu também tenho esse post: http://alissonmachado.com.br/docker-basico/

Jenkins vamos aprender agora.

Então vamos lá, primeira coisa que vou fazer é clonar o repositório:

PS C:\Users\1511 MXTI> git clone https://github.com/AlissonMMenezes/Chapter10
Cloning into 'Chapter10'...
remote: Enumerating objects: 72, done.
remote: Counting objects: 100% (72/72), done.
remote: Compressing objects: 100% (68/68), done.
Receiving objects:  79% (57/72)used 0 (delta 0), pack-reused 0 eceiving objects:  77% (56/72)
Receiving objects: 100% (72/72), 17.01 KiB | 791.00 KiB/s, done.
Resolving deltas: 100% (37/37), done.

e provisionar a minha VM.

PS C:\Users\1511 MXTI\Chapter10> vagrant up --provision
Bringing machine 'docker' up with 'virtualbox' provider...
==> docker: Importing base box 'ubuntu/bionic64'...
==> docker: Matching MAC address for NAT networking...
==> docker: Setting the name of the VM: Chapter10_docker_1591817408579_33553
==> docker: Clearing any previously set network interfaces...
==> docker: Preparing network interfaces based on configuration...
    docker: Adapter 1: nat
    docker: Adapter 2: hostonly
==> docker: Forwarding ports...
    docker: 22 (guest) => 2222 (host) (adapter 1)
==> docker: Running 'pre-boot' VM customizations...
==> docker: Booting VM...

Assim que a sua máquina terminar de subir, logue nela via ssh:

PS C:\Users\1511 MXTI\Chapter10> vagrant ssh
vagrant@docker:~$ sudo su -
root@docker:~#

E ai a gente pode executar o comando do Docker para subir um servidor Jenkins.

root@docker:~# docker run -tdi --restart=always --name jenkins -p 8080:8080 -p 50000:50000 jenkins/jenkins:lts

Nesse caso estou mapeando as portas 8080 para acessar o Jenkins e 50000 para o Jenkins Slave que a gente vai subir mais adiante.

Assim que o container do Jenkins terminar de subir, você pode acessar exatamente por esse endereço: http://192.168.33.11:8080/ , no Vagrant, foi configurado para que a VM suba com esse IP.

Ao acessar o Jenkins pela primeira, ele vai te pedir para informar uma senha inicial, para que você possa prosseguir com a instalação:

Você pode pegar a senha utlizando o comando abaixo:

root@docker:~# docker exec -ti jenkins cat /var/jenkins_home/secrets/initialAdminPassword
70fd86c5bd2a4d9ea1dd8df3c5c1de1e

E ai é só prosseguir com o padrão Next, Next Finish.

No final eu defini usuário e senha como admin / admin.

Agora a gente já pode importar a nossa pipeline do Git, então vamos criar uma New Job, do tipo Multibranch Pipeline chamada API Pipeline, na configuração em Repository HTTPS URL eu coloquei o mesmo repositório do inicio do post. https://github.com/AlissonMMenezes/Chapter10.git

Após salvar a essa New Job, o Jenkins já vai escanear o repositório em busca de um arquivo chamado Jenkinsfile, ler esse arquivo e exibir todos os estágios da Pipeline como na imagem abaixo, onde temos.

Preparing the Environment – Code Quality – Tests – Build – Deploy

O conteúdo do Jenkinsfile é esse abaixo:

pipeline {
    agent  any;
    stages {
        stage('Preparing the environment') {
            steps {
                sh 'python -m pip install -r requirements.txt'
            }
        }
        stage('Code Quality') {
            steps {
                sh 'python -m pylint app.py'
            }
        }
        stage('Tests') {
            steps {
                sh 'python -m pytest'
            }
        }
 
    stage('Build') {
          agent { 
            node{
              label "DockerServer"; 
              }
          }
          steps {
              sh 'docker build https://github.com/AlissonMMenezes/Chapter10.git -t chapter10:latest'
          }
      }        
      stage('Deploy') {
          agent { 
            node{
              label "DockerServer"; 
              }
          }
          steps {
              sh 'docker run -tdi -p 5000:5000 chapter10:latest'
          }
      }
    }
 
}

Em cada estapa eu estou utilizando um módulo do python diferente, para preparar o ambiente, temos o pip, que vai instalar todos as dependências de aplicação.
O pylint que vai fazer a verificação da qualidade de código e o pytest que vai executar os testes funcionais da API. Todo o código utilizado eu copiei desse post aqui: http://alissonmachado.com.br/python-flask-decorators-e-pytest/

Então vamos lá, a única coisa que preciso fazer dentro do container, é instalar o python e o pip, então na minha VM eu vou rodar os seguintes comandos:

root@docker:~# docker exec -ti -u 0 jenkins apt clean
root@docker:~# docker exec -ti -u 0 jenkins apt update
root@docker:~# docker exec -ti -u 0 jenkins apt install python python-pip -y

E também configurar a própria VM como node do Jenkins, pois no final da Pipeline precisamos de um servidor com Docker instalado para gerar a imagem e fazer o deploy.

Então em Manage Jenkins > Manage Nodes and Clouds > New Node, vou criar um node chamado DockerServer.

Na configuração de Remote Root Directory eu defini /tmp, e ai ao clicar no Node já cadastrado você vai ver uma imagem com as linhas de comando que você tem que executar para subi-lo.

Na VM com Docker, vou executar os seguintes comandos:

root@docker:~# apt install openjdk-8-jre-headless -y
root@docker:~# wget http://192.168.33.11:8080/jnlpJars/agent.jar
root@docker:~# java -jar agent.jar -jnlpUrl http://192.168.33.11:8080/computer/DockerServer/slave-agent.jnlp -secret 70e5458b9cffa23da790ba2682f9a4b8dc1d79356a36c26d34296a57b5bc9e44 -workDir "/tmp"

Feito isso o node já deve estar rodando perfeitamente, então a gente pode executar a pipeline manualmente e ver se ela vai rodar.

E ai está a pipeline rodando com sucesso =)

0 0 vote
Article Rating
Subscribe
Notify of
guest
0 Comentários
Inline Feedbacks
View all comments