Integração Contínua: Introdução

Automatize tarefas manuais, e garanta mais velocidade e qualidade nos processos de desenvolvimento de software. Além ainda de uma breve introdução a Gradle, Liquibase e Spring Boot.

Nessa série de tutoriais irei ensinar como efetuar integração contínua, utilizando Jenkins, em projetos Java Web.

Introdução

As demandas por softwares cresceram e crescem exponencialmente, todo esse dinamismo trouxe uma grande mudança em como fazemos software, podemos citar algumas mudanças como a adoção cara vez maior de equipes especializadas em testes, o conceito de desenvolvimento orientado a testes, cobranças por testes unitários e afins, integrações entre diversas aplicações, metodologias ágeis, etc. Mas como garantir, ou pelo menos melhorar, a integração de todo esse universo em um projeto?

A integração contínua não resolve todas as mudanças, mas consegue automatizar diversos trabalhos manuais, melhorando muito os processos de desenvolvimento. Com ela conseguimos atualizar os ambientes da equipe de testes automaticamente, até a própria equipe pode fazer isso se necessário, é possível executar e monitorar os testes automatizados da aplicação, e também verificar periodicamente as integrações entre as aplicações, tudo isso configurável para executar conforme a necessidade de cada projeto.

A integração contínua é iniciada à partir de uma tarefa, que pode ser configurada para verificação SCM (verificação periódica de alteração de código enviados a servidores git, svn, cvs, etc), por período de tempo, scripts remotos, webservices, manualmente, entre outros.

Nesse artigo a iniciação da integração contínua acontecerá por SCM, porém já fiz de diversas formas e caso precise de alguma ajuda para configurar pode me contatar que terei prazer em ajudar.

Nos próximos tópicos vou externar um pouco da minha experiência, e problemas que vivenciei ao longo da minha carreira, e como a integração contínua ajudou a resolver diversos deles.

Problemas Frequentes em Projetos

O primeiro e mais preocupante dos problemas é a falta de conscientização da importância da criação de testes nos projetos. Com a realidade que vivemos hoje um desenvolvedor atualizado e conscientizado sabe da importância dos testes automatizados.

O projeto deve ter no mínimo testes unitários. Testes de integração e aceitação podemos dizer que é um nível mais avançado de qualidade, mas não menos importante.

Outros problemas enfrentados são:

  • Garantir que os testes estão passando a cada nova implementação ou manutenção do código. Dependendo do tempo que os testes demoram para executar, por conta dos testes integrados e de aceitação, fica difícil cobrar do desenvolvedor a execução de todos os testes na sua máquina sempre. O mínimo que pode se esperar é a execução dos testes unitários;
  • Garantir que os testes das novas implementações estão sendo feitos;
  • Garantir que as novas implementações ou manutenção do código não quebraram o código fonte, impossibilitando assim a geração do pacote. Situações de pressão podem fazer com que o desenvolvedor deixe a qualidade de lado, focando somente na entrega, o que dificulta a manutenção do código no futuro;
  • Geração manual de diversos builds por dia, projetos com muitos pacotes são mais complicados ainda. Isso faz com que o desenvolvedor perca horas gerando builds, fazendo com que não foque no seu principal objetivo que é codificar;
  • Execução dos scripts e versionamento dos bancos de dados em diversos ambientes;

Além de diversos outros problemas não citados acima, dos quais muitos de nós sabemos que enfrentamos no dia a dia.

Integração Contínua suas Vantagens e as Melhoras nos Projetos

Todos os problemas citados acima, com exceção da conscientização, podem ser minimizados ou totalmente resolvidos com a integração contínua.

Vejam as soluções:

  • Conseguimos garantir que todos os testes estão passando a cada nova
    implementação ou manutenção de código, com feedback rápido caso algum erro aconteça.
  • Testes integrados e de aceitação podem demorar muito tempo para executar, podemos deixar a responsabilidade da execução para o Jenkins, desonerando o desenvolvedor de perder muito tempo aguardando a execução na sua máquina local. Se os testes integrados e de aceitação não demorarem muito vale a pena sim executar na máquina local antes de commitar.
  • Além de gerar os pacotes automaticamente, o Jenkins nos permite configurar a automatização da implantação dos pacotes nos ambientes. Isso é uma grande vantagem, pois tira a responsabilidade da geração de pacotes na máquina do desenvolvedor, além da ideia de permitir que outras pessoas decidam a hora de gerar o pacote e de subir no ambiente. Por exemplo, o desenvolvedor pode corrigir um bug, commitar no versionador e avisar o pessoal da qualidade, e quando eles acharem que devem subir a versão eles subirão.
  • Execução automática dos scripts no banco de dados em diversos ambientes.

Com a maturidade dos processos de integração contínua da equipe é possível inclusive preparar uma pipeline (termo que usaremos para descrever uma sequência de tarefas no Jenkins para efetuar um build) para subida em ambientes de produção.

Integração Contínua nas Arquiteturas Microservices e Monolíticas

Arquiteturas Microservices

Com a criação cada vez maior de projetos orientados a webservices, muitos projetos têm aplicado a arquitetura orientada a microservices, esse conceito consistem em criar diversos micro projetos com pequenas obrigações de negócio e fazendo com que se comuniquem entre si através de webservices.

O fato de se ter muitos micro projetos faz com se gerem muitos builds, aumentando assim exponencialmente o tempo manual de builds, e ficando mais propício a falhas humanas.

Com a integração contínua é possível automatizar toda a geração e implantação dos diversos pacotes, além claro de garantir a qualidade dos pacotes e a comunicação entre eles cobrindo com testes integrados a camada de comunicação.

Arquiteturas Monolíticas

As arquiteturas monolíticas, arquiteturas conservadoras aonde é mantido apenas um pacote para o projeto, apesar de terem apenas um build também sofrem com a complexidade de execução de seus testes e configurações, e necessitam de um feedback rápido sobre possíveis erros e a garantia da qualidade do projeto, e pode desfrutar também da implantação automática do pacote.

Conclusões

Independente da arquitetura do projeto e quantidade de ambientes, a geração de builds podem se tornar desafios épicos se precisarem serem feitos manualmente. Mesmo se o projeto for pequeno e não for complexo fazer todo esse procedimento manualmente, porque não automatizar o build com integração contínua e focar no desenvolvimento de código?

Imaginem um ambiente com integração continua que sempre garante a entrega do pacote para a equipe de qualidade automaticamente? Sem a necessidade de negociação para geração e implantação do pacote (ou pacotes).

No próximo tópico iremos preparar a configuração do projeto Java.

Você também pode visualizar o repositório no github.

Anúncios
Marcado com: , , , , , , , , , , , , , , , , , , , , , , , , ,
Publicado em Desenvolvimento de Software, DevOps, Git, Integração Contínua, Java, Selenium
4 comentários em “Integração Contínua: Introdução
  1. Pedro Henrique de Oliveira Silva disse:

    Parabéns pelo post 😀 Ficou bem completo. Só acredito que separar em tópicos fica mais fácil a leitura. Mas show de bola mano 😀

  2. Evandro disse:

    Opa… tudo bem Fábio? O conteúdo do posto é excelente, parabéns!
    Ele foi terminado? Cheguei na camada de Services e Controller e parece que falta alguma coisa.
    Um grande abraço!

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: