Gerenciar controle de versão com um servidor de desenvolvimento central (LAMP)

Estou trabalhando em uma equipe pequena com até 5 desenvolvedores (web). Como nossa equipe está crescendo com frequência e tivemos problemas com várias pessoas trabalhando no mesmo código, decidimos configurar um VCS.

Situação atual

Atualmente, estamos trabalhando com um servidor de desenvolvimento central (LAMP). Portanto, todo desenvolvedor trabalha na mesma base de código e, se o código estiver testado e pronto para o nosso servidor ativo, basta copiá-lo via ftp. Eu sei que isso é algum tipo de fluxo de trabalho do ano 1600, mas sim - é o que é e também o motivo dessa pergunta.

No servidor de desenvolvimento, nossa estrutura de diretórios fica assim:

/var/www 
      /Project1 
      /Project2 
      /Project3 
      ...

Além disso, existem alguns pequenos aplicativos que não são da web - aplicativos para Android / iPhone / Windows 8 etc. e algumas ferramentas C # que também devem ser incluídas no VCS.

Objetivo e problemas

Nosso objetivo é obter uma configuração limpa para um VCS, que funciona em conjunto com um software de rastreamento de problemas, nos permite trabalhar juntos no mesmo projeto ao mesmo tempo, sem sobrescrever nossos códigos e simplesmente nos oferece a vantagem do controle de versão.

Penso que a primeira pergunta para nós é: qual tecnologia devemos usar. Alguns de nós já experimentaram subversão. Mas como o git está se tornando o "padrão" e existem muitos argumentos "pro git" entre os usuários da web, tendemos a usar o git.

Aí começa nossa incerteza. Para usar o git - um VCS descentralizado - parece que precisamos começar a usar servidores de desenvolvimento separados no computador de cada desenvolvedor. Os problemas com isso são:

• Algumas vezes, trabalhamos em computadores diferentes; portanto, quando esquecemos de enviar o código, temos um problema.
• Teríamos que trabalhar com máquinas virtuais porque os servidores de desenvolvimento devem ser os mesmos do nosso servidor ativo (isso simplesmente não seria aplicável em nosso ambiente, acredite em mim, não é possível).
• O servidor de desenvolvimento geralmente também servia como um servidor de "teste" ou "apresentação", onde os não desenvolvedores davam uma olhada no que estava acontecendo.

Existe outra configuração possível com o git para que possamos nos beneficiar do sistema enquanto ainda estamos usando um único servidor de desenvolvimento (!)? Talvez com diretórios diferentes para cada desenvolvedor. Ou ainda podemos trabalhar na mesma base de código, talvez bloqueando os arquivos em que estamos trabalhando e enviá-los para um repositório. Talvez seja importante dizer que, embora isso tenha se tornado um fator para nós, ainda é incomum que vários desenvolvedores trabalhem na mesma parte de um aplicativo ao mesmo tempo.

Você está no caminho certo, aqui.

Talvez com diretórios diferentes para cada desenvolvedor.

Sim, diretórios definitivamente diferentes para cada desenvolvedor.

A máquina em que você está é bastante desinteressante. Apenas garanta que cada desenvolvedor efetue login como ele mesmo e faça check-out de uma cópia do repositório git em seu próprio diretório inicial. Você terminará com várias cópias do código que estão no seu sistema de arquivos, mas ei, o disco está livre.

É verdade que o git suporta operações descentralizadas. Mas você não o usará dessa maneira em seu fluxo de trabalho típico. Apenas certifique-se de que um repositório simples esteja disponível em algum servidor conveniente e peça a todos que o utilizem. Acesse-o via http, ssh ou mesmo através do sistema de arquivos, se desejar.

Você mencionou uma área de "teste" como parte do seu fluxo de trabalho. Faça um favor a si mesmo. Contrate outro desenvolvedor, chamado Jenkins, que também faz check-out do seu código usando o git. Ele foi implementado aqui: http://jenkins-ci.org/ (e roda em http://tomcat.apache.org/download-70.cgi ). Dessa forma, cada envio ao repositório central disponibilizará imediatamente uma versão atualizada do seu site no diretório inicial do Jenkins, onde você poderá testá-lo rapidamente e executar verificações de sanidade. Chamamos isso de Integração Contínua e definitivamente melhorará seu fluxo de trabalho.

 It's maybe important to say that while it became a factor for us it is still uncommon that multiple developers work on the same part of an application at the same time.

Se poucas pessoas trabalham na mesma máquina e na mesma base de código, as coisas precisam dar errado. Por causa da substituição e porque se alguém quebra algo, os outros têm que esperar até a correção para testar suas coisas.

Você precisa distinguir alguns ambientes. Parece que você precisa de três (muito comuns):

• Produção - onde o projeto é realmente usado pelos usuários finais.
• Preparação - local em que o desenvolvedor mescla seu trabalho com outros desenvolvedores, testa-o e, às vezes, os clientes podem espiar nessa área.
• Desenvolvimento - onde cada desenvolvedor trabalha sozinho, antes de se fundir com outros.

Normalmente, o ambiente de desenvolvimento significa que o desenvolvedor da máquina trabalha. Se você deseja mantê-lo em uma máquina compartilhada, também pode fazê-lo. Ambientes e máquinas são algo dissociados. Você só precisa ter uma base de código diferente para cada projeto, desenvolvedor e ambiente.

Portanto, no caso de Git e 5 desenvolvedores na empresa, haveriam 5 repositórios para o ambiente de desenvolvimento . Para o ambiente de armazenamento temporário (código de mesclagem), porque não é uma boa ideia enviar para repositórios não vazios, você precisará de um repositório para mesclar e outro para testar o código e mostrar o estado atual do cliente. Se o servidor de produção tiver outro Git lá. Caso contrário, você apenas transfere os arquivos para produção via FTP a partir do ambiente de teste . Poucos repositórios para cada projeto.

E o fluxo de trabalho é o seguinte: você trabalha em seu ambiente de desenvolvimento , quando adiciona um recurso ou corrige um bug, envia as alterações para o repositório simples do ambiente de armazenamento temporário e realiza isso sem o uso de explícitos (um gancho Git pode fazer isso de uma só vez) e quando o projeto estiver pronto para lançar uma nova versão, você a envia (ou transfere via FTP) para a produção .

Algumas vezes, trabalhamos em computadores diferentes; portanto, quando esquecemos de enviar nosso código, temos um problema.

Bem, se você precisar criar um ambiente de desenvolvimento no mesmo servidor compartilhado, poderá sincronizar seus arquivos da máquina local para o servidor através de algo como rsync ou mapear uma unidade de rede ou qualquer outra coisa, mas isso sempre será um pouco mais lento do que trabalhar na máquina local . Trabalhar localmente, no entanto, tem o problema que você mencionou. Mesmo sem VCS. Como ao usar o FTP - se você alterar algo na sua máquina e esquecer de transferi-lo - a mesma coisa acontece. Mas você não deseja mesclar seu código desmontado ao ambiente de preparação , com certeza. Ele precisa permanecer em desenvolvimento até atingir um estado razoável.

We would have to work with virtual machines because the dev servers should be the same as our live server (This would simply not be enforceable in our environment, believe me it's not possible).

Os servidores wev sem GUI não usam muitos recursos. Eu acho que vocês poderiam trabalhar no código e testá-lo em todos em sua própria máquina. Portanto , ambiente de desenvolvimento localmente, e apenas teste no servidor compartilhado. Você pode conferir algo como o Vagrant para ajudar no gerenciamento de imagens de máquinas virtuais. Portanto, você deve garantir que cada projeto obtenha as configurações corretas. Isso garantiria que vocês testassem da mesma maneira, sejam mais seguros (agora, se o servidor compartilhado quebrar, ninguém pode continuar trabalhando, e você precisa ter um bom backup lá) e mais rápido (sem necessidade de transferência até a fusão). O Git tem dez SVN melhores nesse assunto, pois mantém o repositório completo em cada máquina com histórico e tudo mais. Se um PC quebrar, ainda existem boas cópias em outro lugar.

Além disso, coisas como Gitosis podem ajudá-lo a gerenciar as configurações de repo do ambiente de armazenamento temporário , e o Redmine ou outro software de gerenciamento de projetos geralmente tem maneiras de se integrar ao VCS.

porque o git está meio que se tornando o "padrão" e existem muitas pessoas "pro git" entre os usuários da web que costumamos usar o git.

Esta é uma base pobre para fazer escolhas no mundo da SCM. Git não é "padrão", mas sim "moda", com muito barulho ao seu redor. "Pro Git" é mais fanboyismo do que decisão sensata e fundamentada em muitos casos

trabalhamos juntos no mesmo projeto ao mesmo tempo, sem sobrescrever nossos códigos e simplesmente nos dá a vantagem do controle de versão

As ramificações de qualquer SCM permitirão que você o obtenha, mesmo com o Git (palavra-chave: "Git-flow")