Qual é o objetivo de um “Build Server”? [fechadas]

Não trabalhei para organizações muito grandes e nunca trabalhei para uma empresa que tivesse um "Build Server".

Qual é o seu propósito? Por que os desenvolvedores não estão construindo o projeto em suas máquinas locais ou estão? Alguns projetos são tão grandes que máquinas mais potentes são necessárias para construí-los em um período de tempo razoável?

O único lugar em que vejo um Build Server sendo útil é para integração contínua com o servidor de build, construindo constantemente o que está comprometido com o repositório. Será que simplesmente não trabalhei em projetos grandes o suficiente?

Alguém, por favor, me esclareça: Qual é o propósito de um servidor de compilação?

O motivo apresentado é, na verdade, um grande benefício. As compilações que vão para o controle de qualidade devem vir apenas de um sistema que compila apenas a partir do repositório. Desta forma, os pacotes de construção são reproduzíveis e rastreáveis. Os desenvolvedores que criam código manualmente para qualquer coisa, exceto seus próprios testes, são perigosos. Muito risco de coisas não serem verificadas, estarem desatualizadas com as alterações de outras pessoas, etc. etc.

Joel Spolsky sobre este assunto.

Os servidores de construção são importantes por vários motivos.

• Eles isolam o ambiente O desenvolvedor local do Code Monkey diz "Ele compila na minha máquina" quando não compila na sua. Isso pode significar check-ins fora de sincronia ou pode significar que uma biblioteca dependente está faltando. Jar hell não é tão ruim quanto .dll hell; de qualquer forma, usar um servidor de compilação é uma garantia barata de que suas compilações não falharão misteriosamente ou empacotarão as bibliotecas erradas por engano.

• Eles focam as tarefas associadas às compilações. Isso inclui atualizar a tag de construção, criar qualquer pacote de distribuição, executar testes automatizados, criar e distribuir relatórios de construção. A automação é a chave.

• Eles coordenam o desenvolvimento (distribuído). O caso padrão é quando vários desenvolvedores estão trabalhando na mesma base de código. O sistema de controle de versão é o coração desse tipo de desenvolvimento distribuído, mas dependendo da ferramenta, os desenvolvedores podem não interagir muito com o código uns dos outros. Em vez de forçar os desenvolvedores a arriscar construções ruins ou se preocupar com a fusão de código excessivamente agressiva, projete o processo de construção onde a construção automatizada pode ver o código apropriado e processar os artefatos de construção de uma forma previsível. Dessa forma, quando um desenvolvedor confirma algo com um problema, como não fazer o check-in de uma nova dependência de arquivo, ele pode ser notificado rapidamente. Fazer isso em uma área preparada permite sinalizar o código que foi construído para que os desenvolvedores não puxem o código que quebraria sua construção local. O PVCS fez isso muito bem usando a ideia de grupos de promoção. A Clearcase também poderia fazer isso usando rótulos, mas exigiria mais administração do processo do que muitas lojas se preocupam em fornecer.

Qual é o seu propósito?
Assuma a carga das máquinas do desenvolvedor, forneça um ambiente estável e reproduzível para compilações.

Por que os desenvolvedores não estão construindo o projeto em suas máquinas locais ou estão?
Porque com software complexo, muitas coisas podem dar errado quando apenas "compilando". problemas que realmente encontrei:

• verificações de dependência incompletas de diferentes tipos, resultando na não atualização dos binários.
• Comandos de publicação com falha silenciosa, a mensagem de erro no log é ignorada.
• Construir incluindo fontes locais ainda não comprometidas com o controle de fontes (felizmente, nenhuma caixa de mensagem de "clientes malditos" ainda ...).
• Ao tentar evitar o problema acima, construindo a partir de outra pasta, alguns arquivos foram retirados da pasta errada.
• A pasta de destino onde os binários são agregados contém arquivos de desenvolvedor obsoletos adicionais que não devem ser incluídos na versão

Temos um aumento de estabilidade incrível, pois todas as versões públicas começam com um get do controle de origem em uma pasta vazia. Antes, havia muitos "problemas engraçados" que "desapareceram quando Joe me deu um novo DLL".

Alguns projetos são tão grandes que máquinas mais potentes são necessárias para construí-los em um período de tempo razoável?

O que é "razoável"? Se eu executar uma compilação em lote em minha máquina local, há muitas coisas que não posso fazer. Em vez de pagar os desenvolvedores para que as compilações sejam concluídas, pague a TI para comprar uma máquina de construção real.

Será que simplesmente não trabalhei em projetos grandes o suficiente?

O tamanho é certamente um fator, mas não o único.

Um servidor de construção é um conceito distinto para um servidor de integração contínua. O servidor CI existe para construir seus projetos quando mudanças são feitas. Em contraste, existe um servidor de construção para construir o projeto (normalmente uma versão, contra uma revisão marcada) em um ambiente limpo. Ele garante que nenhum desenvolvedor hacks, ajustes, versões não aprovadas de configuração / artefato ou código não confirmado entrem no código lançado.

O servidor de construção é usado para construir o código de todos quando ele é verificado. Seu código pode ser compilado localmente, mas você provavelmente não terá todas as alterações feitas por todos o tempo todo.

Para acrescentar o que já foi dito:

Um ex-colega trabalhava na equipe do Microsoft Office e me disse que uma compilação completa às vezes levava 9 horas. Seria péssimo fazer na SUA máquina, não é?

É necessário ter um ambiente "limpo", livre de artefatos de versões anteriores (e mudanças de configuração) para garantir que builds e testes funcionem e não dependam dos artefatos. Uma maneira eficaz de isolar é criar um servidor de compilação separado.

Concordo com as respostas até agora no que diz respeito à estabilidade, rastreabilidade e reprodutibilidade. (Muito 'ity, certo?). Tendo SOMENTE trabalhado para grandes empresas (Saúde, Finanças) com MUITOS servidores de construção, eu acrescentaria que também se trata de segurança. Já viu o filme Office Space? Se um desenvolvedor descontente cria um aplicativo bancário em sua máquina local e ninguém mais olha ou testa ... BOOM. Superman III.

Essas máquinas são usadas por vários motivos, todos tentando ajudá-lo a fornecer um produto superior.

Um uso é simular uma configuração típica do usuário final. O produto pode funcionar no seu computador, com todas as suas ferramentas de desenvolvimento e bibliotecas configuradas, mas o usuário final provavelmente não terá a mesma configuração que você. Por falar nisso, outros desenvolvedores não terão exatamente a mesma configuração que você. Se você tiver um caminho codificado em algum lugar de seu código, provavelmente funcionará em sua máquina, mas quando Dev El O'per tenta construir o mesmo código, não funciona.

Também podem ser usados ​​para monitorar quem quebrou o produto por último, com qual atualização e onde o produto regrediu. Sempre que um novo código é verificado, o servidor de compilação o constrói e, se ele falhar, fica claro que algo está errado e o usuário que fez o commit por último é o culpado.

Para obter qualidade consistente e obter a compilação 'fora de sua máquina', para detectar erros de ambiente e para que todos os arquivos que você se esqueça de registrar no controle de origem também apareçam como erros de compilação.

Eu também o uso para criar instaladores, pois eles demoram muito para fazer na área de trabalho com assinatura de código, etc.

Usamos um para sabermos que as caixas de produção / teste têm as mesmas bibliotecas e versões dessas bibliotecas instaladas que estão disponíveis no servidor de compilação.

É uma questão de gerenciamento e teste para nós. Com um servidor de construção, sempre sabemos que podemos construir nossa linha de "tronco" principal a partir do controle de versão. Podemos criar uma instalação mestre com um clique e publicá-la na web. Podemos executar todos os nossos testes de unidade cada vez que o código é verificado para ter certeza de que funciona. Ao reunir todas essas tarefas em uma única máquina, é mais fácil acertar repetidamente.

Você está certo que os desenvolvedores podem construir em suas próprias máquinas.

Mas essas são algumas das coisas que nosso servidor de compilação nos compra, e dificilmente somos fabricantes de compilação sofisticados:

• Problemas de controle de versão (alguns foram mencionados em respostas anteriores)
• Eficiência. Os desenvolvedores não precisam parar para fazer compilações localmente. Eles podem iniciá-lo no servidor e passar para a próxima tarefa. Se as compilações forem grandes, esse é ainda mais tempo que a máquina do desenvolvedor não está ocupada. Para aqueles que fazem integração contínua e testes automatizados, ainda melhor.
• Centralização. Nossa máquina de construção tem scripts que fazem a construção, distribuem para ambientes UAT e até mesmo para preparação de produção. Mantê-los em um lugar reduz o incômodo de mantê-los sincronizados.
• Segurança. Não fazemos muito de especial aqui, mas tenho certeza que um administrador de sistema pode fazer com que as ferramentas de migração de produção só possam ser acessadas em um servidor de compilação por certas entidades autorizadas.

Talvez eu seja o único ...

Acho que todos concordam que se deve

• use um repositório de arquivos
• fazer compilações a partir do repositório (e em um ambiente limpo)
• use um servidor de teste contínuo (por exemplo, controle de cruzeiro) para ver se algo está quebrado após suas "correções"

Mas ninguém se preocupa com as versões criadas automaticamente. Quando algo foi quebrado em uma construção automática, mas não está mais - quem se importa? É um trabalho em progresso. Alguém consertou.

Quando você deseja fazer uma versão de lançamento, você executa uma compilação do repositório. E tenho certeza de que você deseja marcar a versão no repositório naquele momento e não a cada seis horas quando o servidor estiver funcionando.

Portanto, talvez um "servidor de construção" seja apenas um nome impróprio e, na verdade, um "servidor de teste contínuo". Caso contrário, soa praticamente inútil.

Um servidor de construção fornece uma espécie de segunda opinião sobre o seu código. Quando você faz o check-in, o código é verificado. Se funcionar, o código tem qualidade mínima.

Além disso, lembre-se de que as linguagens de baixo nível demoram muito mais para compilar do que as de alto nível. É fácil pensar "Bem, olhe, meu projeto .Net compila em alguns segundos! Qual é o problema?" Algum tempo atrás, tive que mexer em alguns códigos C e havia esquecido quanto tempo leva para compilar.

Um servidor de compilação é usado para agendar tarefas de compilação (por exemplo, compilações noturnas) de projetos geralmente grandes localizados em um repositório que às vezes pode levar mais do que algumas horas.

Um servidor de construção também fornece uma base para depósito, sendo capaz de capturar todas as partes necessárias para reproduzir uma construção no caso de outros terem direitos de propriedade.