melhorar nossa estratégia de implantação

Temos um aplicativo de comércio eletrônico que desenvolvemos em nossa empresa. É uma aplicação LAMP razoavelmente padrão que desenvolvemos há cerca de 3 anos. Desenvolvemos o aplicativo em um domínio de teste, aqui adicionamos novos recursos e corrigimos bugs etc. Nosso rastreamento de bugs e desenvolvimento de recursos são todos gerenciados em uma solução de subversão hospedada (unfuddle.com). Como os bugs são relatados, fazemos essas correções no domínio de teste e, em seguida, confirmamos as alterações no svn quando estamos felizes que o bug foi corrigido. Seguimos esse mesmo procedimento com a adição de novos recursos.

Vale ressaltar a arquitetura geral do nosso sistema e aplicativo em nossos servidores. Cada vez que um novo recurso é desenvolvido, lançamos essa atualização em todos os sites usando nosso aplicativo (sempre um servidor que controlamos). Cada site que utiliza nosso sistema basicamente usa exatamente os mesmos arquivos para 95% da base de código. Temos duas pastas em cada site que contêm arquivos sob medida para esse site - arquivos / imagens css etc. Além disso, as diferenças entre cada site são definidas por várias definições de configuração no banco de dados de cada site.

Isso vai para a própria implantação real. Quando estamos prontos para lançar algum tipo de atualização, executamos um comando no servidor em que o site de teste está. Isso executa um comando de cópia (cp -fru / testsite / / othersite /) e passa por cada força do vhost atualizando os arquivos com base na data da modificação. Cada servidor adicional no qual hospedamos possui um vhost no qual sincronizamos a base de código de produção e, em seguida, repetimos o procedimento de cópia em todos os sites desse servidor. Durante esse processo, removemos os arquivos que não queremos que sejam substituídos, retornando-os quando a cópia estiver concluída. Nosso script de implementação executa várias outras funções, como aplicar comandos SQL para alterar cada banco de dados, adicionar campos / novas tabelas etc.

Ficamos cada vez mais preocupados com o fato de nosso processo não ser suficientemente estável, tolerante a falhas e também ser um método de força bruta. Também estamos cientes de que não estamos fazendo o melhor uso do subversion, pois temos uma posição em que trabalhar em um novo recurso nos impediria de lançar uma importante correção de bug, pois não estamos usando ramos ou tags. Também parece errado que tenhamos tanta replicação de arquivos em nossos servidores. Também não podemos executar facilmente uma reversão do que acabamos de lançar. Realizamos um diff antes de cada lançamento, para que possamos obter uma lista de arquivos que serão alterados para que possamos saber o que foi alterado depois, mas o processo de reversão ainda seria problemático. Em termos de banco de dados, comecei a procurar no dbdeploy como uma solução potencial. O que realmente queremos é uma orientação geral sobre como podemos melhorar nosso gerenciamento e implantação de arquivos. Idealmente, queremos que o gerenciamento de arquivos seja mais intimamente vinculado ao nosso repositório, para que uma implementação / reversão esteja mais conectada ao svn. Algo como usar o comando export para garantir que os arquivos do site sejam iguais aos arquivos de repo. Também seria bom se a solução talvez também parasse a replicação de arquivos em nossos servidores.

Ignorando nossos métodos atuais, seria muito bom ouvir como outras pessoas abordam o mesmo problema.

para resumir ...

• Qual é a melhor maneira de fazer com que os arquivos em vários servidores fiquem sincronizados com o svn?
• Como devemos evitar a replicação de arquivos? links simbólicos / alguma outra coisa?
• Como devemos estruturar nosso repositório para que possamos desenvolver novos recursos e corrigir os antigos?
• Como devemos acionar lançamentos / reversões?

desde já, obrigado

EDITAR:

Recentemente, li muitas coisas boas sobre o uso do Phing e Capistrano para esse tipo de tarefa. Alguém pode dar mais informações sobre eles e quão bons eles seriam para esse tipo de tarefa?

Meu conselho para fazer versões é ter versões de recursos e versões de manutenção. Lançamentos de recursos seriam os lançamentos que recebem novos recursos. Estes são adicionados ao seu tronco de subversão. Quando você acha que esses recursos estão completos, você os ramifica em um ramo de lançamento. Quando seu processo de controle de qualidade estiver satisfeito com esta versão, você a codifica e implanta o código nos seus servidores.

Agora, quando você obtém um relatório de bug, confirma essa correção na ramificação e a porta no tronco. Quando estiver satisfeito com o número de bugs corrigidos, você pode marcar e implantar uma versão de manutenção.

É importante que você tenha uma ramificação da sua base de código ativo (ou tenha a capacidade de criar uma conhecendo a revisão ao vivo) que é separada da sua ramificação de desenvolvimento, para poder implantar correções no seu código ativo sem precisar implantar novos recursos ou código não testado.

Eu recomendaria usar o sistema de empacotamento nativo da sua distribuição para implantar um novo código. Se você possui um pacote que contém toda a sua base de código, sabe que todo o seu código foi implantado em uma espécie de operação atômica, pode ver rapidamente qual versão está instalada, pode verificar sua base de código usando a soma de verificação de seus pacotes. A reversão é apenas um caso de instalação da versão do pacote instalada anteriormente.

O único obstáculo que posso ver implementando isso é que você parece ter várias cópias da base de código para diferentes clientes executando em um único servidor. Tentaria organizar seu código para que todos os clientes executem os mesmos arquivos e não usem cópias. Não sei como isso seria fácil para você, mas reduzir o número de cópias com as quais você precisa lidar reduzirá enormemente sua dor de cabeça.

Estou assumindo que, como você mencionou o LAMP, você está usando PHP ou outra linguagem de script, que não requer um processo de compilação. Isso significa que você provavelmente está perdendo um processo maravilhoso chamado Integração Contínua. O que isso significa basicamente é que seu código está sendo testado continuamente para garantir que ele ainda esteja em um estado liberável. Toda vez que alguém faz check-in do novo código, um processo o executa e executa o processo de compilação e teste. Com uma linguagem compilada, você normalmente usa isso para garantir que o código ainda seja compilado. Em todos os idiomas, você deve aproveitar a oportunidade para executar testes de unidade (seu código está em unidades testáveis, não é?) E testes de integração. Para sites, uma boa ferramenta para testar testes de integração é o Selenium. Em nossas construções Java, também medimos a cobertura e as métricas de código para ver como progredimos ao longo do tempo. O melhor servidor de CI que encontramos para Java é o Hudson, mas algo como o buildbot pode funcionar melhor para outras linguagens. Você pode criar pacotes usando o servidor de IC.

Começamos a usar o Puppet (principal produto da Reductive Labs). É uma estrutura baseada em Ruby para automatizar tarefas sys-admin. Eu estava no puppetcamp há algumas semanas e aqui estão os links de vídeo:

Apresentando Luke Kanies - Introdução de Marionetes

Além disso, se você quiser ver todas as apresentações feitas no puppetcamp em são francisco, este é o link:

Apresentações feitas sobre como os outros usaram o Puppet

Desfrutar.