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.
*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
- Obter o código do repositório GitHub,
- Compilar o projeto,
- Criar uma imagem Docker
- ,
- Salvar essa imagem no
- Docker Hub.
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 (estamos usando a versão 2.249.2 LTS), será necessário o instalar:
Git, Docker e de suas respectivas variáveis de ambiente configuradas. Clique- Configurar as variáveis de ambiente:
- Git,
- Docker,
- Jenkins
Clique aqui para mais detalhes sobre a instalação do Jenkins e como vincular o Docker ao Jenkins.
- No Cronapp, o modo Modo Avançado deve estar habilitado;
- Usaremos como repositório:
- para
- para o repositório de código;
Dockerhub- Docker Hub: para o repositório de imagem.
- É necessário que Jenkins possua os seguintes plugins instalados:
| Dica |
|---|
Caso Caso pretenda usar o Github GitHub e Dockerhub Docker Hub como seus repositórios de código e imagens respectivamente, certifique-se de que os dados sensíveis não sejam disponibilizados em repositórios públicos. Ao criar repositório nesses sistemas, o padrão é estarem configurados como públicos. |
Pipeline
| Nota |
|---|
Para esse tutorial utilizamos uma imagem Docker com o Jenkins, sendo executado no Linux. |
Âncora arquivoJenkinsfile arquivoJenkinsfile
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.
Abaixo temos o conteúdo do Jenkinsfile que encontramos ao criar um projeto no Cronapp.
| Bloco de código | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||||
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')
stringchoice(defaultValuechoices: 'https://index.docker.io/v1/'['true', 'false'], description: 'URLIncluir do Registry (projeto mobile.', name: 'CRONAPP_MOBILE_APP')
string(defaultValue: 'https://index.docker.io/v1/', description: 'URL do Registry (padrão é o docker hub).', name: 'CRONAPP_DOCKER_REGISTRY', trim: false)
string(defaultValue: 'INFO_SEU_USUARIO/NOMEDAIMAGEM', description: 'Informe o nome de sua imagem (se for registry privado, informe o caminho completo).', name: 'CRONAPP_DOCKER_IMAGE_NAME', trim: false)
string(defaultValue: 'INFO_ID_CREDENCIAL_DOCKERHUB', description: 'Informe a credencial (secret) usada para acesso ao registry.', name: 'CRONAPP_DOCKERHUB_ACCESS', trim: false)
string(defaultValue: 'INFO_URL_REPO_GIT_HTTPS', description: 'Informe o endereço HTTPS do repositório Git.', name: 'CRONAPP_GIT_URL', trim: false)
string(defaultValue: 'INFO_ID_CREDENCIAL_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} .
--build-arg MOBILE_APP=${CRONAPP_MOBILE_APP} .
'''
}
}
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: faz o build do 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 DockerhubDocker Hub;
- Docker Clean: apaga todas as imagens sem tags, incluindo as que foram geradas no build.
Passos
Criar credenciais
Vamos usar o Jenkins para armazenar as credenciais de acesso do Github e Dockerhub, impedindo que esses dados fiquem expostos.
Para os passos abaixo é necessário acessar a aplicação do Jenkins em seu navegador.
Configuração inicial
| Dica |
|---|
| Esse tópico apresentará os passos iniciais ao acessar o Jenkins pela primeira vez, caso já possua um Jenkins configurado, pule para o tópico Criar credenciais. |
A primeira coisa solicitada pelo Jenkins é a Senha de administrador, essa senha é exibida no log de instalação e também está em um arquivo no diretório apontado na própria tela 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
abaixo). Informe a senha e clique em Continuar.
Figura 2 - Janela ao executar o Jenkins pela primeira vez
Selecione a opção Install suggested plugins para que o Jenkins adicione automaticamente os plugins mais comuns.
Figura 2.1 - Opção para adicionar os plugins mais utilizados
Aguarde o Jenkins instalar os plugins (Figura 2.2).
Figura 2.2 - Instalação dos plugins Jenkins
Após a instalação dos plugins será exibido uma janela para cadastrar um usuário administrador, informe os campos solicitados e clique em Save and Continue.
Figura 2.3 - Criação do primeiro usuário administrador
Em seguida o Jenkins exibirá o domínio e porta em que estará rodando, Clique em Save and Finish.
Figura 2.4 - Criação do primeiro usuário administrador
No último passo o Jenkins apenas informa que a instalação está completa, clique em Start using Jenkins para ser direcionado até a página de Bem-vindo da aplicação Jenkins (Figura 2.5).
Figura 2.5 - Página inicial da aplicação Jenkins
Âncora criarCredencial criarCredencial
Criar credenciais
Vamos usar o Jenkins para armazenar as credenciais de acesso do GitHub e Docker Hub, impedindo que esses dados fiquem expostos.
No link Painel de controle (canto superior esquerdo), posicione o cursor do mouse até exibir o ícone do menu e clique para exibir o menu (destaque 1 da figura 3), acesse Gerenciar Jenkins > Manager Credentials para abrir a página de Credentials. Na lista Stores scoped to Jenkins, posicione o cursor do mouse em (global) (coluna Domains) até exibir o ícone do menu e clique para exibir as opções (destaque 2 na figura 2.1), selecione a opção Add Credentials.
Figura 3 - Acesso ao gerenciador de Credenciais do Jenkins
Alimente os campos com os seus dados do Github e clique no botão Create para cadastrar, após isso, clique em Credentials no breadcrumbs (destaque 1 da figura 3.1) para retornar a tela do gerenciar de credenciais (Figura 3) e criar um nova credencial, dessa vez para preencher com os dados do Dockerhub.
Figura 3.1 - Acesso ao gerenciador de Credenciais do Jenkins
Âncora devops-credencial-github devops-credencial-github
GitHub
- Kind: deixe a opção padrão Username with password.
- Scope: selecione a opção Global.
- Username do GitHub.
- Password: informe o token gerado a partir da sua conta do Github.
- ID: para facilitar a identificação, sugerimos adicionar o nome do projeto e serviço da credencial (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 4.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 4.3)
Figura 4.3 - Configuração do parâmetro CRONAPP_TAG_VERSION
Name: informe "CRONAPP_TAG_VERSION", estamos usando esse parâmetro no arquivo Jenkinsfile. Parâmetro obrigatório.
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 apenas "*".
Branch Filter: informe a expressão regular "refs/heads/(.*)$" (sem aspas), 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.
- Description: adicione uma descrição própria ou informe o mesmo valor do ID (ex.: "Credencial do Github.").
Âncora devops-credencial-dockerhub devops-credencial-dockerhub
Docker Hub
- Kind: deixe a opção padrão Username with password.
- Scope: selecione a opção Global.
- Username do Docker Hub.
- Password do Docker Hub.
- 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.: "Credencial do Dockerhub.").
| Dica |
|---|
Anote os ID's utilizados nas 2 credenciais, usaremos eles ao executar o pipeline. |
Ao final, teremos 2 credenciais globais (Figura 3.2).
Figura 3.2 - Após finalizar o cadastro do Github e Dockerhub
Adicionar plugins
O próximo passo será a instalação do Plugin Docker Pipeline.
Figura 4 - Instalação do plugin Docker pipeline
- No link Painel de controle (canto superior esquerdo), posicione o cursor do mouse até exibir o ícone do menu e clique para exibir o menu (destaque 1 da figura 4), acesse Gerenciar Jenkins > Gerenciar extensões para abrir a página de Gerenciador de extensões.
- Selecione a aba Disponíveis.
- Digite o nome do plugin: Docker pipeline
- Marque a caixa de seleção do plugin.
- Clique em Baixar agora e instalar após o reinício.
O Jenkins mudará para a página de instalação do plugin, aguarde esse procedimento e, em seguida, logue novamente na aplicação.
Criar o Job
No link Painel de controle (canto superior esquerdo), posicione o cursor do mouse até exibir o ícone do menu e clique para exibir o menu (destaque 1 da figura 5), acesse Nova tarefa para abrir a página inicial de configuração. Informe um nome para o job (destaque 2), selecione a opção Pipeline (3) e clique em Tudo certo (4)
Figura 4.1 - Criando um Job do tipo Pipeline
Âncora parametroBranch parametroBranch
Parâmetro da Branch
Antigamente recomendávamos o uso de um plugin para listar todas as Branchs e Versões tags do Git do projeto, permitindo apenas selecionar a versão do projeto que iria ser utilizada no pipeline. Porém, esse plugin deixou de ser mantido e apresenta falha de segurança, assim, vamos criar um parâmetro para informar manualmente a branch ou versão tag que será utilizada.
Marque a opção Esta construção é parametrizada e na caixa de seleção exibida, selecione a opção Parâmetro de texto (Figura 5),
Figura 5 - Novo parâmetro do tipo texto
Será exibido uma área com alguns campos, preencha como informado abaixo.
Figura 5.1 - Configuração do parâmetro CRONAPP_TAG_VERSION
- Nome: nome do parâmetro utilizado no arquivo Jenkinsfile, informe exatamente o valor "CRONAPP_TAG_VERSION".
- Valor padrão: nome da branch ou tag version que será utilizado, esse valor poderá ser alterado depois, ao executar o pipeline.
- Descrição do campo.
Script do pipeline
Ainda nessa página, desça até a área de configuração do Pipeline e preencha os campos abaixo. Nessa área, os campos identados serão exibidos a medida que os campos superiores forem selecionados.
Figura 6 Figura 4.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
- SCM: selecione a opção "Git".
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 5.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 5.1).
Figura 5.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 5.2), cancele a execução, pois o Jenkins já obteve as configurações iniciais do Jenkinsfile. Caso não cancele, uma mensagem de erro aparecerá e a operação será finalizada automaticamente.
- campos.
Finalizada as configurações, clique em Salvar.
Obter demais Parâmetros do pipeline
Para executar o pipeline são necessários outros parâmetros além do que cadastramos no tópico Parâmetro da Branch. Esses parâmetros podem ser obtidos automaticamente a partir do arquivo Jenkinsfile do projeto. Assim, será necessário executar o pipeline pela primeira vez, durante a execução, o Jenkins irá obter os parâmetros definidos e apresentará uma falha, já que os parâmetros ainda não foram preenchidos.
Na página do Job criado, clique em Construir com parâmetros (destaque 1 da figura 7) e na tela de Construção será exibido apenas o parâmetro criado anteriormente: CRONAPP_TAG_VERSION. Nesse momento não é necessário informar um valor correto neste campo, clique em Construir (2).
Figura 7 - Configuração do sistema de controle de código do pipeline
Após o erro de execução (figura 7.1), o Jenkins já possui todos os parâmetros necessários.
Figura 7.1 - Erro gerado na primeira execução do pipelineFigura 5.2 - Inicie a execução e cancele assim que exibir "Running on Jenkins in..."
Âncora executar-pipeline executar-pipeline
Executar o pipeline
Clique novamente em Construir com parâmetros para (destaque 1 da figura 8) para voltar a tela de execução do pipeline (Figura 6. 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.
Jenkinsfile, mais o parâmetro "CRONAPP_TAG_VERSION" que incluímos no tópico Parâmetro da Branch.
Configure os campos como descritos abaixo.
Figura 8 Figura 6.1 - Tela de execução do Pipeline
CRONAPP_USE_CONTEXT: selecione "true" para usar a configuração do perfil de permite incluir no pacote final do projeto as configurações usadas no perfil do banco de dados do arquivo context.xml configurado no Cronapp, ou defina "false" para que as conexões de banco de dados não sejam levadas para dentro do WAR(arquivo
context.xml). Para mais informações, veja o link Novos parâmetros para gerar .war. acesse o tópico "Exportando war via comando (High-code)" em Importar e exportar projetos.Aviso Fique atento ao definir essa opção como "true", isso fará com que as configurações de banco de dados sejam armazenadas na imagem, gerando alto risco ao disponibilizar publicamente essa imagem.
Recomendamos alterar essa opção para "false", porém será necessário usar recursos do orquestrador Docker, onde é possível informar as conexões de banco de dados necessárias ao contêiner/aplicação por meio de secretspor meio de secrets.
- true: adiciona as configurações do perfil de banco de dados;
- false: não adiciona as configurações do perfil de banco de dados.
- CRONAPP_TIER: informe qual perfil de banco de dados será usado.
- DEV: desenvolvimento;
- PROD: produção.
- CRONAPP_MOBILE_APP: permite incluir na raiz do pacote um diretório (
mobileapp/) com a aplicação mobile do projeto.- true: inclui a aplicação mobile;
- false: não inclui a aplicação mobile.
- 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 DockerhubDocker Hub.
- CRONAPP_GIT_URL: Endereço endereço (HTTPS) do repositório Git.
- CRONAPP_GIT_USERPASS: identificador da credencial de acesso ao GithubGitHub,
- CRONAPP_TAG_VERSION: Tag tag version ou branch que será usada na construção.
Selecione a opções desejadas e clique Clique em Construir para iniciar o processo.
Na página Stage View é possível acompanhar o andamento de cada etapa do processo (destaque 1 da figura 68.21). O tempo de execução do pipeline pode variar bastante, mas em média costuma levar de 10 8 a 20min, sendo influenciado por fatores como velocidade da internet e o hardware do equipamento que executa o Jenkins.
| Dica |
|---|
Para reduzir esse tempo, use métodos para adicionar |
seu |
Figura 68.2 1 - Job do pipeline em execução
Em caso de falha no processo, acesse o Console Output (2 da figura 68.21) e verifique o que causou o erro.
Resultado
Finalizado a execução do pipeline, acesse o Docker Hub para verificar a imagem criada do seu projeto.
Figura 9 - Imagem Docker gerada através do pipeline deste tutorial
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.
| Problema | Sugestão de solução |
|---|---|
| Dependendo da forma como de como o Git foi instalado, talvez seja necessário alterar as configurações de variáveis de ambiente. clique aqui para mais detalhes. | |
| Verifique se o cliente Docker está aberto e em execução. |
| Verifique se o plugin Docker Pipeline está instalado no Jenkins. |
Resultado
Finalizado a execução do pipeline, acesse o Dockerhub para verificar a imagem criada do seu projeto.
Figura 7.1 - Imagem Docker gerada através do nosso pipeline