Olá, pessoal!

Hoje queremos demonstrar para vocês como podemos utilizar Docker e Jenkins para o build de aplicações de forma rápida e fácil. Primeiro, vamos entender como é o ambiente de diversas empresas de TI hoje. Você que está lendo este artigo, possivelmente vai se identificar com o cenário.

Hoje diversas empresas utilizam a ferramenta Jenkins para build e deploy de aplicações, muitas vezes (se não forem todas), essa máquina de Jenkins são compartilhadas entre diversos times – Java, PHP, Python, Rails e NodeJS acabam utilizando. O que deixa essa máquina com ferramentas desnecessárias para as equipes, sobrecarregando o sistema e qualquer problema acaba parando todas as equipes.

Porém, existem alguns casos mais organizados em que cada equipe terá uma máquina para realizar o build, o que torna o processo um pouco melhor. Porém, sempre que sair uma nova versão de softwares alguém precisa ficar atualizando essa máquina, o que pode acabar, por muitas vezes, impactando em prazos do projeto.

Então, existe o que acreditamos que seja a melhor solução, que seria a utilização de containers para o build de suas aplicações. Mas por que usar containers?

• Só dependências para aquela aplicação;
• Fácil manutenção;
• Ambiente de produção e local iguais;
• Escabilidade.

Então, visto porquê devemos utilizar containers para realizar o build, vamos mostrar como podemos utilizar essas duas ferramentas em sincronia.

Primeiramente, vamos até as configurações do nosso repositório e clicar em “WebHooks & Services:

Vamos até “Add Service” e adicionar o “Jenkins (Github Plugin)”:

Agora, em nosso servidor com o Docker instalado, vamos iniciar o container que terá o Jenkins Master instalado.

############# SERVIDOR1 #################
docker run -p 8080:8080 -p 50000:50000 -d jenkins

Iniciado, agora vamos até o nosso browser e digitaremos http://ipserver:8080 e vamos fazer a configuração base do Jenkins:

Para pegar a senha, você irá executar:

docker exec idcontainer cat /var/jenkins_home/secrets/initialAdminPassword

Na pŕoxima página, você pode escolher a opção de usar os plugins recomendados, então, depois irá pedir para você criar um usuário:

Feito isso, agora estamos na página inicial do Jenkins:

Esse será nosso servidor de Jenkins Master, que será o responsável por avisar e mandar rodar alguns comandos no nosso servidor, onde estará o Docker. Para isso, vamos acessar o servidor 2 e realizar a instalação do Jenkins:

############# SERVIDOR2 #################
sudo wget -O /etc/yum.repos.d/jenkins.repo http://pkg.jenkins-ci.org/redhat/jenkins.repo
sudo rpm --import https://jenkins-ci.org/redhat/jenkins-ci.org.key
sudo yum install jenkins -y
sudo yum install java -y 
sudo service jenkins start/stop/restart
sudo chkconfig jenkins on
firewall-cmd --zone=public --add-port=8080/tcp --permanent
firewall-cmd --zone=public --add-service=http --permanent
firewall-cmd --reload
sudo yum install java-1.7.0-openjdk -y

Após realizar a instalação do servidor 2, vamos até o nosso servidor de Jenkins Master adicionar o outro nó nele, colocando o IP e a forma pela qual o agente foi instalado (para isso, você deve ir até “Gerenciar Jenkins” >> “Gerenciar nós”).

Após isso, você irá clicar em novo nó, colocar o ip desse novo servidor e clicar na opção de “Permanent” e OK. Após isso, irá aparecer algo parecido com a tela abaixo. então, você terá que fazer download do slave.jar, ir até o outro servidor e executar o comando do Java que é mostrado na imagem abaixo, porém, com as suas configurações.

Feito isso, vamos até a tela da esquerda na opção de configurações e configurar parecido com a imagem abaixo: a parte mais importante dessa tela é a configuração do “rótulo” que é o apelido que vamos dar a esse servidor e também o “uso” que dizemos que vamos executar nesse servidor apenas como jobs.

Agora, vamos até a página inicial do nosso Jenkins e criaremos o nosso build. Vamos até “Novo Build”:

Após selecionar “Novo Build”, vamos até a opção de configuração:

Vamos colocar o nome do nosso servidor de slave na opção de “Restringe onde este projeto pode ser executado”:

Abaixo, vamos colocar o nosso caminho do “GitHub” e também de qual branch irá baixar o código:

Vamos marcar a opção de “Build when a change is pushed to github” e também a opção de quanto em quanto tempo vamos consultar o nosso “SCM”.

Em nosso último passo, vamos colocar os comandos que iremos executar em nosso servidor. Vamos criar uma imagem a partir do Dockerfile que está em nosso GitHub e, após isso, vamos iniciar o container com essa imagem:

Então, por hoje era isso pessoal! Espero que tenham gostado do artigo e gostaríamos que vocês interagissem através de comentários, propondo novos temas e arquiteturas que vocês gostariam que a gente fizesse com Docker.

Obrigado!

Referências:

• https://www.docker.com/sites/default/files/RA_CI%20with%20Docker_08.25.2015.pdf
• https://jenkins.io/solutions/docker/
• https://wiki.jenkins-ci.org/display/JENKINS/Installing+Jenkins