Geral

O que é integração contínua?

Por em

Já pensou em um mundo perfeito no seu processo de desenvolvimento de software, onde você encontra e investiga bugs mais rapidamente, melhora a qualidade do seu software e reduz o tempo que leva para validar e lançar novas atualizações do seu software? A verdade é que isso hoje é mais possível do que nunca. Esse mundo perfeito que eu descrevi pra você acima trata-se de uma prática de desenvolvimento de software chamada de Integração Contínua. Veja a definição completa de acordo com a opinião de Martin Fowler, um famoso arquiteto de software da comunidade.

Integração Contínua é uma prática de desenvolvimento de software onde os membros de uma equipe integram seu trabalho frequentemente, geralmente pelo menos uma vez por dia. Cada integração é verificada por um build automatizado (incluindo testes que são fundamentais) para detectar erros e devolver um feedback o mais rápido possível. Essa abordagem reduz significativamente problemas com integração e permite que a equipe desenvolva software mais coeso de forma mais rápida”.

Em um primeiro momento tudo parece ser muito simples e bonito, porém antes de você começar a implementar essa prática de desenvolvimento de software é importante você entender o processo como um todo e quais ferramentas você precisa para implantar essa metodologia de desenvolvimento de software. Este será o nosso objetivo neste artigo.

O processo

Como o processo de desenvolvimento de software era feito antigamente? No passado, os desenvolvedores de uma equipe podiam trabalhar isoladamente por um longo período e só juntar suas alterações à ramificação mestre quando concluíssem seu trabalho. Dessa forma, a junção das alterações de códigos era difícil e demorada, além de resultar no acúmulo de erros sem correção por longos períodos. Estes fatores dificultavam uma distribuição de atualizações rápida para os clientes. Como o processo de integração contínua melhora significativamente esse processo antigo? Veja a imagem abaixo para entendermos o processo como um todo.

Acho que o primeiro ponto a analisarmos é que o processo de integração contínua estimula muito mais a colaboração e menos o isolamento. As equipes enviam suas alterações de código fonte, com frequência em um repositório central compartilhado, evitando assim o acúmulo de codificação para a integração ao repositório. Algumas metodologias ágeis ditam que o desenvolvedor só pode considerar como pronto o trabalho quando o trabalho estiver pelo menos sincronizado com o repositório central. Continuando o processo, após o código ser sincronizado, compilações automatizadas do seu software são geradas e testes são realizados com o objetivo de detectar bugs mais rapidamente. Esta parte da compilação e testes são realizados por um servidor de CI.

Neste processo verificamos então que precisamos de, pelo menos, duas ferramentas para implementar o nosso processo de integração contínua, que são o repositório central compartilhado para armazenar o código fonte e um servidor de CI (Integração contínua). Vejamos agora que ferramentas temos disponíveis no mercado que pode nos ajudar nesta demanda.

Sistemas de controle de versão

Quando falamos de repositório central compartilhado, estamos falando na realidade de um sistema de controle de versão. Porque em um processo de integração contínua, precisamos de muito mais do que apenas de um lugar para guardar o código, precisamos versionar o código, precisamos saber quem fez a alteração e precisamos prevenir que os desenvolvedores refaçam o trabalho já que foi desenvolvido. Esse é o objetivo de usar sistemas de controle de versão. O controle de versão possibilita que vários desenvolvedores trabalhem em paralelo sobre os mesmos arquivos sem que um sobrescreva o código de outro, o que traria reaparecimento de defeitos e perda de funcionalidades.

O controle de versão é composto de duas partes: o repositório e a área de trabalho. O repositório armazena todo o histórico de evolução do projeto, registrando toda e qualquer alteração feita em cada item versionado. O desenvolvedor não trabalha diretamente nos arquivos do repositório. Ao invés disso, usa uma área de trabalho que contém a cópia dos arquivos do projeto e que é monitorada para identificar as mudanças realizadas. Essa área é individual e isolada das demais áreas de trabalho. A sincronização entre a área de trabalho e o repositório é feita através dos comandos commit e update. O commit envia um pacote contendo uma ou mais modificações feitas na área de trabalho (origem) ao repositório (destino). O update faz o inverso, isto é, envia as modificações contidas no repositório (origem) para a área de trabalho (destino). Cada commit gera uma nova revisão no repositório, contendo as modificações feitas, data e autor. Uma revisão funciona como uma “foto” de todos os arquivos e diretórios em um determinado momento da evolução do projeto. As “fotos” antigas são mantidas e podem ser recuperadas e analisadas sempre que desejado. O conjunto dessas revisões é justamente o histórico do projeto.

Existe um conjunto de ferramentas para controle de versão centralizado, entre elas temos o CVS, Subversion, Git, entre outros. Estas ferramentas permitem aos desenvolvedores trabalharem em conjunto, possuindo um Servidor central responsável pelo versionamento do sistema e possibilitando que vários clientes possam acessar, visualizar, modificar e enviar novos códigos se for necessário. Aqui na School of Net, nós temos um excelente material para você quer aprender a trabalhar com esses sistemas de controle de versão em seu processo de desenvolvimento de software.

Servidor de CI

Após você estruturar todo o seu processo de versionamento do código, o próximo passo é configurar um servidor de integração contínua para realizarmos as compilações automatizadas e executarmos os testes para validação do código. Hoje existem diversas ferramentas no mercado que podem lhe ajudar a atingir este objetivo, desde ferramentas open-source como o Jenkins e ferramentas pagas como o CircleCI, TravisCI, AWS CodeBuild, Azure Devops e muitas outras.

Vamos agora entender em mais detalhes o que são compilações automatizadas e os testes de validação de código que vão ser executadas pelo seu servidor de CI. No contexto do desenvolvimento de software, compilação (build) refere-se ao processo que converte arquivos e outros recursos sob a responsabilidade dos desenvolvedores em um produto de software em sua forma final ou consumível. A compilação pode incluir compilação de código fonte, empacotamento de arquivos compilados em formatos compactados (como jar, zip), instaladores de produção e criação ou atualização de esquema ou dados do banco de dados. A compilação é automatizada quando essas etapas são repetíveis, não requerem intervenção humana direta e podem ser executadas a qualquer momento sem nenhuma informação além daquelas armazenadas no repositório de controle do código-fonte.

Após termos essa versão consumível do nosso software, é hora de validar o nosso código-fonte através de testes. Testes unitários, integrados e funcionais automatizados ajudam a dar muito mais eficiência ao seu processo de integração contínua. Uma boa prática é a utilização de frameworks XUnits para esta tarefa, exemplo: Junit para Java, PHPUnit para PHP, CppUnit para C++, entre outros. Recomendamos para você iniciar com seu servidor de integração contínua, o Jenkins, que é um servidor de automação baseado em Java que possui centenas de plug-ins de integração e entrega contínua para suportar a criação, a implementação e automação do seu processo de CI. Basicamente, o Jenkins verifica as alterações no seu sistema de controle de versão, aciona uma compilação automatizada quando detecta esta alteração e realiza os testes solicitados e após isso ele notifica as equipes dos resultados encontrados. Ele tem uma comunidade bem engajada, fácil instalação e várias integrações que o tornam um servidor líder de Integração Contínua. Aprenda sobre a instalação e configuração do Jenkins neste excelente material aqui na School of Net .

Concluindo

A integração contínua traz diversos benefícios para o seu processo de desenvolvimento de software. Com a integração contínua você pode encontrar bugs mais rapidamente, lançar novas versões de software com mais confiabilidade e melhorar a performance do time de desenvolvimento como um todo.

O objetivo é sempre tentar evoluir o seu processo de desenvolvimento a fim de torná-lo mais eficiente, ágil e simples. Abstrair tarefas manuais e repetitivas, assim como obter um rápido feedback de erros vai lhe ajudar bastante nessa evolução.

Referências

https://blog.pronus.io/posts/conceitos-basicos-de-controle-de-versao-de-software-centralizado-e-distribuido/

https://martinfowler.com/articles/continuousIntegration.html