Explicação simples da integração contínua

32

Como você definiria a integração contínua e quais componentes específicos um servidor de IC contém?

Quero explicar a alguém do departamento de marketing o que é Integração Contínua. Eles entendem o controle de origem - ou seja, eles usam o Subversion. Mas gostaria de explicar a eles adequadamente o que é o IC. O artigo da Wikipedia nunca o define adequadamente, o artigo de Martin Fowler fornece apenas o seguinte, que é basicamente uma tautologia seguida por uma vaga explicação de 'integração':

Integração Contínua é uma prática de desenvolvimento de software em que os membros de uma equipe integram seu trabalho com frequência, geralmente cada pessoa se integra pelo menos diariamente - levando a várias integrações por dia. Cada integração é verificada por uma construção automatizada (incluindo teste) para detectar erros de integração o mais rápido possível.

Atualização : enviei esta imagem para eles, não encontrei uma mais simples.

insira a descrição da imagem aqui

Atualização 2 : Feedback do departamento de marketing (para o momento em que havia três perguntas):

Na verdade, eu gosto das três respostas - por diferentes razões. Sinto vontade de fazer login apenas para agradecer a todos!

Obviamente ele não pode - então obrigado em seu nome :)

Atualização 3 : percebi que, olhando para o artigo da Wikipedia, ele contém os princípios que, quando você pega apenas os títulos, é uma lista bastante boa:

  1. Manter um repositório de código
  2. Automatize a compilação
  3. Faça o autoteste da compilação
  4. Todo mundo se compromete com a linha de base todos os dias
  5. Todo commit (para a linha de base) deve ser construído
  6. Mantenha a construção rápida
  7. Teste em um clone do ambiente de produção
  8. Facilite a obtenção dos produtos mais recentes
  9. Todos podem ver os resultados da versão mais recente
  10. Automatizar a implantação
icc97
fonte
3
oO Seu departamento de marketing usa o Subversion? Tentados a votação para perto como "Too localizada" ... ;-)
Jeroen
@ Jeroen Sim, na verdade, para arquivos no site. Eu criei um belo botão vermelho grande em uma página da web que diz 'Faça' para atualizar o subversion no servidor. :)
icc97 20/05

Respostas:

27

Quando alguém altera os arquivos que compõem o produto de software e tenta fazer check-in (em outras palavras, tenta integrar as alterações no código principal do produto), você deseja garantir que o produto de software ainda possa ser construído com êxito.

Geralmente, existe um sistema externo, chamado servidor de IC , que periodicamente ou a cada alteração, captura os arquivos de origem do controle de versão e tenta criar o produto (compilação / teste / pacote). Se o servidor de IC puder fazer uma compilação com êxito, as alterações foram integradas com êxito.

O servidor de CI também deve ser capaz de transmitir se a compilação falhar ou for bem-sucedida, para sistemas como o Jenkins (um dos servidores de CI mais usados ​​hoje em dia) terão maneiras de enviar e-mails / textos, bem como uma interface da Web do tipo painel. um monte de informações sobre compilações atuais e passadas, quem fez o check-in do código, quando as coisas quebraram etc. (Na sua imagem acima, esse seria o Mecanismo de Feedback ).

O IC é importante, pois garante que, continuamente, você tenha um produto em funcionamento. Isso é importante para todos os desenvolvedores que estão trabalhando no produto de software, bem como para todas as pessoas que desejam ter acesso a lançamentos diários do produto, como o controle de qualidade.

c_maker
fonte
1
A integração contínua se preocupa com o status da compilação, mas também com os testes.
Quentin Pradet
1
e implantação, não basta compilar e executar testes, mas você também deve enviar os binários para um ambiente, para que também possam ser testados por pessoas (ou ferramentas automatizadas).
Gbjbaanb 17/05
1
Como a pergunta pedia uma explicação simples , deixei de fora muitos detalhes (na maioria das vezes específicos do projeto / equipe) que poderiam entrar em um sistema de IC.
#maker
Isso depende do desenvolvimento orientado a testes? Código que compila nem sempre é o código que funciona certo? Sem testes para falhar quando o código não está pronto, como o sistema de CI saberia se o código realmente foi integrado com sucesso?
precisa saber é o seguinte
1
@ user828584: Na minha resposta, sugiro que 'test' faça parte de uma compilação. E como uma observação lateral, o TDD é diferente de ter testes para verificar a qualidade. Como efeito colateral do TDD, você terá testes bem escritos, mas poderá fazer testes sem fazer nenhum TDD.
#maker
33

Eu acho que para o seu departamento de marketing não é importante como o IC funciona , mas o que significa para novos lançamentos do seu software .

O CI significa, idealmente, que você pode produzir uma nova versão potencialmente liberável do seu software todos os dias, pronta para ser apresentada ou vendida ao seu cliente, com alguns novos recursos, funcionalidades ou correções adicionadas. Isso não significa que você deve entregar a nova versão todos os dias, mas pode, se quiser.

Por exemplo, se você tem um novo conjunto de recursos planejado para ser lançado oficialmente para a versão "2015" do seu software e possui partes desse conjunto já codificadas e integradas hoje, os profissionais de marketing podem usar a versão atual do seu software. software e mostrá-lo - com mais ou menos segurança - na próxima conferência agora em 2013. Sem o CI, eles precisavam pedir à sua equipe um congelamento não planejado do código, cada membro da equipe precisava integrar o recurso incompleto no qual está trabalhando no produto, eles podem não ter testes automáticos suficientes prontos e adivinhem o que acontecerá na conferência - a "versão alfa" do seu lançamento do 2015er terá um risco muito maior de travar, especialmente quando os novos recursos forem demonstrados.

Doc Brown
fonte
4
+1 por abordá-lo da perspectiva do benefício que oferece.
Poke
17

Você não pode saber o que é IC, a menos que saiba o que costumávamos fazer. Imagine um sistema com 3 partes. Há uma interface do usuário que reúne dados e os coloca no banco de dados. Existe um sistema de relatórios que faz relatórios a partir do banco de dados. E há algum tipo de servidor que monitora o banco de dados e envia alertas por email se determinados critérios forem atendidos.

Há muito tempo, isso seria escrito da seguinte maneira:

  1. Concorde com o esquema do banco de dados e com os requisitos - isso levaria semanas, pois precisava ser perfeito, pois em breve você verá por que
  2. Atribua 3 desenvolvedores, ou 3 equipes independentes de desenvolvedores, às 3 partes
  3. Cada desenvolvedor trabalhava em sua peça e a testava usando sua própria cópia do banco de dados, por semanas ou meses.

Durante esse período, os desenvolvedores não executariam o código um do outro, nem tentariam usar uma versão do banco de dados criada pelo código de outra pessoa. O redator do relatório apenas adicionaria manualmente um monte de dados de amostra. O gravador de alerta adicionaria manualmente registros que simulavam eventos de relatório. E o escritor da GUI examinaria o banco de dados para ver o que a GUI havia adicionado. Com o tempo, os desenvolvedores perceberiam que a especificação estava errada de alguma forma, como não especificar um índice ou ter um tamanho de campo muito curto e "corrigi-lo" em sua versão. Eles podem dizer aos outros, quem pode agir de acordo, mas geralmente essas coisas aparecem em uma lista para mais tarde.

Quando todas as três partes eram completamente codificadas e testadas por seus desenvolvedores, e algumas vezes até testadas pelos usuários (mostrando a eles um relatório, uma tela ou um alerta por email), chegava a fase de "integração". Isso costumava ser orçado em vários meses, mas ainda continuava. Essa alteração no tamanho do campo por dev 1 seria descoberta aqui e exigiria que os desenvolvedores 2 e 3 fizessem grandes alterações no código e possivelmente alterações na interface do usuário também. Esse índice extra causaria seu próprio caos. E assim por diante. Se um dos desenvolvedores foi instruído por um usuário para adicionar um campo e o fez, agora seria a hora dos outros dois também adicioná-lo.

Essa fase foi brutalmente dolorosa e praticamente impossível de prever. Então as pessoas começaram a dizer "temos que nos integrar com mais frequência". "Temos que trabalhar juntos desde o início". "Quando um de nós solicita uma mudança [é assim que conversamos] os outros precisam saber sobre isso." Algumas equipes começaram a fazer testes de integração mais cedo, continuando a trabalhar separadamente. E algumas equipes começaram a usar o código e a saída um do outro o tempo todo, desde o início. E isso se tornou integração contínua.

Você pode pensar que estou exagerando essa primeira história. Certa vez, trabalhei para uma empresa em que meu contato me incentivou a verificar algum código que sofria das seguintes falhas:

  • uma tela em que ele não estava trabalhando tinha um botão que ainda não fazia nada
  • nenhum usuário havia assinado o design da tela (cores e fontes precisas; a existência da tela, seus recursos e quais botões ele possuía nas especificações de 300 páginas).

A opinião dele era de que você não coloca as coisas no controle de origem até que elas sejam CONCLUÍDAS. Ele normalmente fazia um ou dois check-ins por ano. Tivemos um pouco de diferença de filosofia :-)

Além disso, se você achar difícil acreditar que as equipes sejam desconectadas em torno de um recurso compartilhado como um banco de dados, você realmente não acreditará (mas é verdade) que a mesma abordagem foi adotada para codificar. Você vai escrever uma função que eu possa chamar? Isso é ótimo, vá em frente e faça isso, apenas codificarei o que preciso enquanto isso. Meses depois, "integrarei" meu código para que ele chame sua API e descobriremos que ele explodirá se eu passar nulo, explodir se retornar nulo (e faz muito isso) retorna itens muito grandes para mim, não aguenta anos bissextos e milhares de outras coisas. Trabalhar de forma independente e depois ter uma fase de integração era normal. Agora parece loucura.

Kate Gregory
fonte
2
Tivemos uma história semelhante na qual atualizamos um aplicativo personalizado desenvolvido no SP 2003 para o SP 2007. Usando o VSS (sim, VSS :), cada desenvolvedor fez check-out de uma parte do arquivo, codificada por uma semana e duas, e depois quando integramos nosso código, boom, que quando o problema começou desde que nosso código se desviou significativamente. Corrigimos o problema de integração por um mês e o projeto alugou um hotel para acomodar aqueles que moram muito longe durante a semana. Naquele dia, aprendi a integrar código diariamente :-)
OnesimusUnbound
@OnesimusUnbound Lembro-me de ter esbarrado do VSS para o Clearcase ... da panela para o fogo. Anos depois, depois de retornar à mesma empresa para tomar bebidas, lembro-me de alguém rindo de um colega desenvolvedor por mencionar esse novo controle de fonte chamado 'Git', "Para o que precisamos de outro sistema de controle de fonte ??".
Icc97 17/05
1
Obrigado - eu tenho strugged entender CI antes simplesmente porque eu não sabia o que a alternativa era
Rhys
Interessante. Para mim, isso parece mais comparar o IC com a cascata. Mas você pode usar uma metodologia não em cascata que evita esses problemas (como desenvolvimento iterativo) e não usa o IC.
Dan Moulding
@DanMoulding Se estou sendo ágil e iterativo e outros enfeites da minha parte de algo maior que não está integrado ao que outra pessoa está fazendo, não estou fazendo CI. Heck, você pode cascata e CI. Projete tudo, codifique tudo, teste tudo se quiser - se todo mundo estiver usando layouts de código / esquema / arquivo de todos os outros o tempo todo, isso é CI mesmo se você estiver usando cascata. A conexão é que, sem o IC, você vive e morre pelo BDUF, porque essa é sua única esperança (e acaba sendo uma esperança fraca) de ter uma fase de integração de duração razoável. A adoção do CI nos permitiu abandonar o BDUF.
Kate Gregory