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

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.

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

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.

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.

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.