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 =)