O modelo DevOps (união das palavras development e operations) combina filosofia de trabalho, ferramentas e práticas que agilizam o processo de entregas e implantação de softwares. Todo o fluxo ocorre em cima de uma estrutura conhecida como Esteira DevOps ou CI/CD (continuous integration / continuous delivery) pipeline e possui uma série de etapas cíclicas que podem variar um pouco, mas em geral possui os seguintes elementos: codificação, compilação. teste, pacote, liberação, configuração e monitoramento.

*Figura 1 - Etapas da Esteira DevOps

Nesse tutorial veremos como configurar o Jenkins para obter um projeto criado no Cronapp e executar as seguintes etapas do pipeline: obter o código do repositório Git, compilar o projeto, criar uma imagem Docker e salvar essa imagem no DockerHub.

Pré-requisitos

Esse tutorial não prevê os passos iniciais para instalação e configuração do Jenkins e Docker. Porém, para executar o Jenkins é será necessário o Java SDK 11, Tomcat 9, Git, Maven, Docker e de suas respectivas variáveis de ambiente configuradas. Clique aqui para mais detalhes sobre a instalação do Jenkins.

• Usaremos como repositório:
• Github: para o repositório de código;
• Dockerhub: para o repositório de imagem:
• É necessário que Jenkins possua os seguintes plugins instalados:
• List Git Branches Parameter;
• Docker Pipeline.

Pipeline

No arquivo Jenkinsfile encontramos uma estrutura que utiliza o Pipeline, uma linguagem de domínio específico (DSL) com base na linguagem de programação Groovy. É utilizada pelo Jenkins para criar e personalizar os jobs.

pipeline {
	agent any
	parameters{ 
		choice(choices: ['true', 'false'], description: 'Selecione se quer usar conexões de banco e parâmetros dentro do conteiner.', name: 'CRONAPP_USE_CONTEXT')
		choice(choices: ['DEV', 'PROD'], description: 'Selecione o perfil do banco de dados (TIER).', name: 'CRONAPP_TIER')
		string(defaultValue: 'tutorialcronapp/esteiradevops', description: 'Informe o nome de sua imagem (se for registry privado, informe o caminho completo).', name: 'CRONAPP_DOCKER_IMAGE_NAME', trim: false)
		string(defaultValue: 'https://index.docker.io/v1/', description: 'URL do Registry (padrão é o docker hub).', name: 'CRONAPP_DOCKER_REGISTRY', trim: false)
		string(defaultValue: 'Esteira-DevOps-dockerhub', description: 'Informe a credencial (secret) usada para acesso ao registry.', name: 'CRONAPP_DOCKERHUB_ACCESS', trim: false)
		string(defaultValue: 'https://github.com/igorandrade83/Esteira-DevOps.git', description: 'Informe o endereço HTTPS do repositório Git.', name: 'CRONAPP_GIT_URL', trim: false)
		string(defaultValue: 'Esteira-DevOps-github', description: 'Informe a credencial (secret) usada para acesso ao reposotório Git.', name: 'CRONAPP_GIT_USERPASS', trim: false)
	}

	stages {
		stage('Git Clone') {
			steps {
				checkout([$class: 'GitSCM', branches: [[name: '${CRONAPP_TAG_VERSION}']], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'CloneOption', noTags: false, reference: '', shallow: false]], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${CRONAPP_GIT_USERPASS}", url: "${CRONAPP_GIT_URL}"]]])
			}
		}

		stage ('Maven and Docker Build') {
			steps {
				sh '''
					docker build -t ${CRONAPP_DOCKER_IMAGE_NAME}:${CRONAPP_TAG_VERSION}-${CRONAPP_TIER} --build-arg TIER=${CRONAPP_TIER} --build-arg CONTEXT_USE=${CRONAPP_USE_CONTEXT} .
				'''
			}
		}

		stage ('Docker Push') {
			steps {
				withDockerRegistry(credentialsId: "${CRONAPP_DOCKERHUB_ACCESS}", url: "${CRONAPP_DOCKER_REGISTRY}") {
					sh '''
						docker push ${CRONAPP_DOCKER_IMAGE_NAME}:${CRONAPP_TAG_VERSION}-${CRONAPP_TIER}
					'''
				}
			}
		}

		stage ('Docker Clean') {
			steps {
				sh '''
					docker image prune -f
				'''
			}
		}
	}
}

Declarações usadas:

• agent any: o Jenkins permite distribuir a carga de compilação para diferentes nós, porém, o "agent any" define que qualquer nó disponível pode realizar essa ação.
• parameters: parâmetros passados para o Jenkins com informações dos repositórios e configurações de banco de dados. Acesse o tópico Executar pipeline para mais detalhes.
• stages: define os passos do pipeline do Jenkins.
  • Git Clone: clona o projeto do repositório de código informado.
  • Maven and Docker Build: executa o projeto e gera uma imagem Docker com base nas configurações do Dockerfile do projeto.
  • Docker Push: envia a imagem recém criada para o Dockerhub,
  • Docker Clean: apaga os arquivos usados na criação da imagem para libera o espaço em disco.

Passos

Criar credenciais

Vamos usar o Jenkins para armazenar as credenciais de acesso do Github e Dockerhub, impedindo que esses dados fiquem expostos.

Abra e logue na interface de configuração do seu Jenkins. No menu Jenkins (destaque 1 da figura 2.1), acesse Jenkins > Gerenciar Jenkins > Manage Credentials. Na página de Credentials, acesse o menu (Global) na lista Stores scoped to Jenkins e selecione a opção Add Credentials (destaque 2 na figura 2.1) para exibir os campos de cadastros.

Figura 2.1 - Acesso ao gerenciador de Credenciais do Jenkins

Github

Alimente os campos como informado abaixo.

Figura 2.2 - Adicionando as credenciais de acesso do Github

• Kind: deixe a opção padrão "Username with password".
• Scope: selecione a opção "Global".
• Username do Github.
• Password do Github.
• ID: para facilitar a identificação, sugerimos adicionar o nome do projeto e serviço da credencial.
  Ex,: "nome_do_projeto-github".
• Description: adicione uma descrição própria ou informe o mesmo valor do ID.
  Ex,: "nome_do_projeto-github".

Salve em seguida.

Dockerhub

Faça o mesmo procedimento com a conta do Dockerhub.

• Kind: deixe a opção padrão "Username with password".
• Scope: selecione a opção "Global".
• Username do Dockerhub.
• Password do Dockerhub.
• ID: para facilitar a identificação, sugerimos adicionar o nome do projeto e serviço da credencial.
  Ex,: "nome_do_projeto-dockerhub".
• Description: adicione uma descrição própria ou informe o mesmo valor do ID.
  Ex,: "nome_do_projeto-dockerhub".

Salve em seguida.

Atualizar o Jenkinsfile

Após criarmos as credenciais de acesso no Jenkins, podemos configurar os parâmetros do arquivo Jenkinsfile em seu projeto no Cronapp. Abra o arquivo que fica na pasta raiz do seu projeto para alterarmos o conteúdo destacado na imagem abaixo.

Figura 3.1 - Arquivo Jenkinsfile

1. INFO_SEU_USUARIO/NOMEDAIMAGEM: substitua pelo seu usuário do Dockerhub e nome da imagem para esse projeto no Dockerhub, separe as duas informações com uma barra "/".
   Ex.: "tutorialcronapp/esteiradevops".
2. INFO_ID_CREDENCIAL_DOCKERHUB: informe a credencial criada para o Dockerhub no Jenkins (passo anterior).
   Ex,: "nome_do_projeto-dockerhub".
3. INFO_URL_REPO_GIT_HTTPS: substitua pelo endereço Git (https) do seu projeto.
   Ex.: "https://github.com/igorandrade83/Esteira-DevOps.git".
4. INFO_ID_CREDENCIAL_GITHUB: informe a credencial criada para o Github no Jenkins (passo anterior).
   Ex,: "nome_do_projeto-github".

Após salvar o arquivo, efetue um Commit/Push para salvar as alterações no repositório Git do seu projeto.

Criar o Job

Acesse novamente a interface de configuração do seu Jenkins e selecione no menu Jenkins: Jenkins > Novo Job (destaque 1 da figura 4.1). Na próxima tela, informe o nome do Job no campo Enter an item name (2 da figura 4.1), selecione a opção Pipeline (3) e clique em OK ao final (4).

Figura 4.1 - Criando um Job do tipo Pipeline

Na aba General, marque a caixa de seleção Este build é parametrizado, clique em Adicionar parâmetro e escolha a opção List Git branches (and more) (Figura 4.2). Se você não estiver vendo essa opção, é provável que ainda não tenha instalado o plugin List Git Branches Parameter em seu Jenkins.

Figura 3.2 - Exibindo os campos de parâmetros do build

Após selecionar a opção List Git branches (and more), apenas os primeiros campos serão exibidos, clique no botão Avançado, logo abaixo do campo Parameter Type, para exibir os demais campos. (Figura 3.3)

Figura 3.3 - Configuração do parâmetro CRONAPP_TAG_VERSION

• Name: informe "CRONAPP_TAG_VERSION", estamos obtendo esse parâmetro do arquivo Jenkinsfile em nosso projeto (destaque 5 na figura 3.1).

• Repository URL: endereço Git (https) do seu projeto.

• Credentials: selecione a credencial de acesso Git criado no primeiro passo desse tutorial.

• Parameter Type: selecione a opção "Branch or Tag".

• Sort Mode: escolha a opção "DESCENDING".

• Tag Filter: informe a expressão regular "refs/heads/(.*)$", ela irá ocultar o início das tags no momento da seleção, facilitando a visualização.

• Branch Filter: informe a expressão regular "refs/heads/(.*)$", ela irá ocultar o início das branchs no momento da seleção, facilitando a visualização.

• Default Value: deixe em branco. (valor padrão)

• Selected Value: selecione a opção "TOP".

• Quick Filter: deixe desmarcado. (valor padrão).

• List Size: deixe o valor "5". (valor padrão).

Ainda nessa tela, clique na aba superior Pipeline e preencha os campos abaixo.

Figura 3.4 - Configuração do sistema de controle de código do pipeline

• Definition: selecione a opção "Pipeline script from SCM".
• SCM: selecione a opção "Git".
• Repositories / Repository URL: endereço Git (https) do seu projeto.
• Repositories / Credentials: selecione a credencial de acesso Git criado no primeiro passo desse tutorial.
• Script Path: nesse campo deve ser informado o endereço do arquivo Jenkinsfile dentro do projeto. Como esse arquivo fica na pasta raiz, informe apenas o nome do arquivo “Jenkinsfile”.
• Demais campos: deixe a configuração padrão do Jenkins nos outros campos.

Finalizada as configurações, clique em Salvar.

Parâmetros do pipeline

Após a criação do Job, precisamos rodar o Jenkins para que ele seja alimentado com as configurações que passamos através do Jenkinsfile. Assim, acesse o job que acabamos de criar e, no menu lateral ou no menu estendido (destaque 1 da figura 4.1), clique em Construir com parâmetros para abrir a página de execução do Pipeline.

Clique no botão Construir para executar (2 da figura 4.1).

Figura 4.1 - Tela de execução do Pipeline

Após aparecer a mensagem Running on Jenkins in <endereço local do projeto> no Console Output (Figura 4.2), já é possível cancelar a execução, pois o Jenkins já obteve as configurações do Jenkinsfile. Caso não cancele, uma mensagem de erro aparecerá e a operação será finalizada automaticamente.

Figura 4.2 - Inicie a execução e cancele assim que exibir "Running on Jenkins in..."

Executar o pipeline

Clique novamente em Construir com parâmetros para voltar a tela de execução do pipeline,(Figura 4.1). Verifique que agora são exibidos todos os parâmetros contidos no arquivo Jenkinsfie. 

Com exceção dos parâmetros de seleção, os campos de entrada de texto atualizamos manualmente quando editamos o Jenkinsfile, dessa forma não será necessário alterá-los.

Figura 5.1 - Tela de execução do Pipeline

• CRONAPP_USE_CONTEXT: selecione "true" para usar algum perfil de banco de dados configurado no Cronapp ou "false" para configurar manualmente depois. 
• CRONAPP_TIER: informe qual perfil de banco de dados será usado.
• CRONAPP_DOCKER_REGISTRY: endereço do Registry usado da imagem, o valor padrão é o Dockerhub.
• CRONAPP_DOCKER_IMAGE_NAME: nome da <conta>/<repositório> da imagem. 
• CRONAPP_DOCKERHUB_ACCESS: identificador da credencial de acesso ao Dockerhub.
• CRONAPP_GIT_URL: Endereço (HTTPS) do repositório Git. 
• CRONAPP_GIT_USERPASS: identificador da credencial de acesso ao Github,
• CRONAPP_TAG_VERSION: Tag ou branch que será usada na construção.

Selecione a opções desejadas e clique em Construir.

Na página Stage View é possível acompanhar o andamento de cada etapa do processo (destaque 1 da figura 5.2). O tempo de execução do pipeline pode variar bastante, mas em média costuma levar de 10 a 30min, sendo influenciado por fatores como velocidade da internet e o hardware do equipamento que executa o Jenkins.

Figura 5.2 - Job do pipeline em execução

Em caso de falha no processo, acesse o Console Output (2 da figura 5.2) e verifique o que causou o erro.

Problemas e soluções

Abaixo descrevemos alguns problemas que podem ocorrer durante a execução do pipeline e como solucioná-los.

Antes de tudo, é preciso ter ciência que o ambiente que for executar o Jenkins necessita do Java SDK 11, Tomcat 9, Git, Maven, Docker e de suas respectivas variáveis de ambiente configuradas. Clique aqui para mais detalhes sobre a instalação do Jenkins.

Resultado

Finalizado a execução do pipeline, acesse o Dockerhub para verificar a imagem criada do seu projeto.

Figura 6.1 - Imagem docker gerada através do nosso pipeline

_{* A Figura 1 foi criada por Kharnagy e está sob licença CC BY-SA 4.0.}