Estratégia de versão do tfs

Use o Team Foundation Version Control.

Neste artigo.

VSTS | TFS 2018 | TFS 2017 | TFS 2018 | VS 2017 | VS 2018 | VS 2018.

Se o seu projeto de software é grande ou pequeno, o uso de controle de versão o mais rápido possível é uma boa idéia. Os sistemas de controle de versão são um software que o ajuda a rastrear as mudanças que você faz no seu código ao longo do tempo. À medida que você edita seu código, você diz ao sistema de controle de versão que faça uma instantâneo de seus arquivos. O sistema de controle de versão guarda esse instantâneo de forma permanente para que você possa recuperá-lo mais tarde se você precisar.

O VSTS e o TFS fornecem dois modelos de controle de versão: o Git, que é o controle de versão distribuído, eo Team Foundation Version Control (TFVC), que é o controle de versão centralizada. Este artigo fornece uma visão geral e um ponto de partida para usar o Team Foundation Version Control. Se você decidir qual tipo de controle de versão VSTS / TFS usar, consulte Escolher o controle de versão correto para o seu projeto.

Por que usar o controle de versão?

Sem controle de versão, você está tentado a manter múltiplas cópias de código em seu computador. Isso é perigoso, pois é fácil mudar ou excluir um arquivo na cópia de código errada, potencialmente perdendo o trabalho. Os sistemas de controle de versão solucionam este problema gerenciando todas as versões do seu código, mas apresentando uma única versão por vez.

Os sistemas de controle de versão oferecem os seguintes benefícios:

Criar fluxos de trabalho - Os fluxos de trabalho de controle de versão impedem o caos de todos usando seu próprio processo de desenvolvimento com ferramentas diferentes e incompatíveis. Os sistemas de controle de versões fornecem execução de processos e permissões para que todos permaneçam na mesma página. Trabalhar com versões - Toda versão possui uma descrição para o que as mudanças na versão fazem, como corrigir um erro ou adicionar um recurso. Essas descrições ajudam você a seguir as mudanças em seu código por versão, em vez de por alterações de arquivo individuais. O código armazenado em versões pode ser visualizado e restaurado a partir do controle de versão a qualquer momento conforme necessário. Isso facilita a base do novo trabalho fora de qualquer versão do código. Code together: o controle de versão sincroniza as versões e garante que suas alterações não entrem em conflito com outras mudanças de sua equipe. Sua equipe depende do controle de versão para ajudar a resolver e prevenir conflitos, mesmo quando as pessoas fazem mudanças ao mesmo tempo. Mantenha um histórico - O controle de versão mantém um histórico de mudanças à medida que seu time salva novas versões do seu código. Esta história pode ser revisada para descobrir quem, por que e quando as mudanças foram feitas. O histórico dá-lhe a confiança para experimentar, uma vez que você pode reverter para uma boa versão anterior a qualquer momento. O histórico permite que você baseie o trabalho em qualquer versão do código, como para corrigir um erro em uma versão anterior. Automatizar tarefas - Os recursos de automação de controle de versão economizam o tempo de sua equipe e geram resultados consistentes. Você pode automatizar testes, análise de código e implantação quando novas versões são salvas no controle de versão.

Há muitas coisas que podem levar seu tempo como desenvolvedor: reproduzir bugs, aprender novas ferramentas e adicionar novos recursos ou conteúdo. À medida que as demandas de seus usuários aumentam, o controle de versão ajuda sua equipe a trabalhar em conjunto e a ser enviada a tempo.

Team Foundation Version Control.

O Team Foundation Version Control (TFVC) é um sistema de controle de versão centralizado. Normalmente, os membros da equipe têm apenas uma versão de cada arquivo em suas máquinas de desenvolvimento. Os dados históricos são mantidos apenas no servidor. Os ramos são baseados em caminho e criados no servidor.

O TFVC permite que você aplique permissões granulares e restrinja o acesso até um nível de arquivo. Como sua equipe verifica todo o trabalho em seu servidor Team Foundation, você pode facilmente auditar alterações e identificar qual usuário verificou em um conjunto de mudanças. Ao usar comparar e anotar, você pode identificar as mudanças exatas que eles fizeram.

O que você quer fazer?

Passe alguns minutos para configurar sua máquina de dev para tirar proveito de todos os benefícios de uma base de código controlada por versão.

Espaços de trabalho do servidor - Antes de fazer alterações, os membros da equipe verificam publicamente os arquivos. A maioria das operações exige que os desenvolvedores sejam conectados ao servidor. Este sistema facilita os fluxos de trabalho de bloqueio. Outros sistemas que funcionam desta forma incluem Visual Source Safe, Perforce e CVS. Com os espaços de trabalho do servidor, você pode escalar bases de código muito grandes com milhões de arquivos por ramificação e arquivos binários grandes.

Espaços de trabalho locais - Cada membro da equipe tira uma cópia da versão mais recente da base de código com eles e funciona de maneira offline conforme necessário. Os desenvolvedores verificam suas mudanças e resolvem conflitos conforme necessário. Outro sistema que funciona dessa maneira é o Subversion.

Você não deve pensar sobre o controle de versão na maioria das situações. O sistema oferece suporte a você quando precisar gerenciar e entender suas mudanças.

Às vezes você precisa reservar algum ou todo o trabalho que você está fazendo. Seu sistema de controle de versão pode tirar parte da dor e reduzir o tempo desperdiçado por interrupções.

Verifique suas mudanças para que sua equipe possa construir, testar e liberar o valor que você criou.

Use ramos e fechaduras para isolar o risco introduzido pelo trabalho realizado por equipes diferentes.

Uma vantagem de um sistema de controle de versão é que você pode olhar para trás no tempo para obter informações detalhadas sobre quais mudanças foram feitas em seus arquivos.

Você pode comparar as pastas do servidor e as pastas locais entre si e visualizar as diferenças entre os conteúdos de cada pasta.

Uma grande vantagem de usar o controle de versão é que várias pessoas podem trabalhar simultaneamente em um arquivo. Uma desvantagem é que às vezes você deve resolver conflitos. Embora possa ser frustrante encontrar conflitos, o sistema fornece informações e ferramentas para ajudá-lo a entender e resolver conflitos.

Quando você precisa impedir que um arquivo ou uma pasta seja verificado e alterado, você pode bloqueá-lo.

Seções relacionadas.

Instale um pouco de software para criar um servidor de compilação e, em seguida, preencha alguns campos para criar um processo de integração contínua (CI) ou de construção noturna que permita aproveitar a potência, conveniência, escalabilidade e confiabilidade de um sistema de compilação automatizado para crie seu aplicativo.

Fornece informações sobre nomesação de sintaxe, convenções e limitações.

Atualmente, não publicamos as seguintes seções. No entanto, você pode ler a versão do Visual Studio 2018 desta orientação.

Em ALM com TFS / VSTS.

blogando sobre Gerenciamento do ciclo de vida do aplicativo com TFS / VSTS.

TFS Build 2018 & # 8230; e controle de versão!

Ultimamente tive algum tempo para jogar um pouco mais com o novo sistema de compilação que foi lançado com o TFS 2018 e que também está disponível para o Visual Studio Online. O novo sistema de compilação foi inicialmente anunciado como build vNext, mas agora com o lançamento do TFS 2018, é seguro chamá-lo de Team Foundation Build 2018 (TFBuild 2018) enquanto o & # 8220; old & # 8221; O sistema de compilação pode ser referido como o sistema de compilação xaml (workflow). Colin Dembovsky tem uma ótima publicação porque você deve mudar para o novo sistema de compilação.

Nos últimos anos, tive que implementar muitas personalizações no sistema de compilação xaml e tornei-me muito produtivo com as atividades de fluxo de trabalho. Ao longo do caminho, desenvolvi uma série de atividades genéricas que eu poderia reutilizar para outras tarefas e eu realmente conhecia meu caminho no fluxo de trabalho de compilação. Em muitos casos, as extensões de compilação TFS foram usadas para não reinventar a roda. Então, na primeira fase, fiquei um pouco cético sobre a ascensão de mais um sistema de construção, mas eu vi claramente algumas vantagens interessantes que são explicadas na publicação por Colin. Uma desvantagem do sistema de compilação xaml é a curva de aprendizado íngreme para dominar o processo de personalização e também o mecanismo de implantação para atualizar o (s) controlador (es) de compilação TFS. Mas, como eu experimentei, uma vez que você chegou lá, você conseguiu integrar personalizações muito poderosas no processo de compilação. De qualquer forma, o & # 8220; old & # 8221; O sistema de compilação não desapareceu e você ainda pode depender dessa funcionalidade por algum tempo no futuro, mas eu recomendo que tenha um bom visual no novo sistema de compilação e use-o para suas definições de compilação novas / futuras.

Nesta publicação, quero compartilhar a forma como eu integrado uma atividade comum no processo de compilação: Versão. Com as etapas de compilação disponíveis, tornou-se extremamente simples ligar seus próprios scripts ao processo de compilação. Nos scripts, você terá acesso a algumas variáveis ​​de compilação predefinidas.

No meu blog anterior escrevi sobre a adoção de uma Estratégia de Versão Global e a existência de um terceiro atributo de versão (opcional): AssemblyInformationalVersion. Vamos usar esta estratégia para adicionar o controle de versão a uma amostra do aplicativo de software Fabrikam.

Minha definição de construção:

Na captura de tela acima, você verá que eu lanço um script powershell (PreBuild. ps1) antes de construir a solução e eu passo um argumento productVersion para o script. O script do powershell fará a magia em segundo plano para substituir todos os valores de versão para AssemblyVersion, AssemblyFileVersion e AssemblyInformationalVersion nos arquivos Assembly Info, com base nesta versão do produto. A versão do produto será passada como um todo aos atributos AssemblyVersion e AssemblyInformationalVersion. O AssemblyFileVersion será substituído por um número de versão completo que consistirá no número de versão maior e menor da versão do produto, uma data baseada em Julian e um número de compilação incremental.

Assembly File Version = 1.0.15236.3.

1 = & gt; tirado de & # 8220; Major & # 8221; versão do produto 0 = & gt; tirado de & # 8220; Minor & # 8221; versão do produto 15236 = & gt; gerado pelo processo de compilação: & # 8220; 15 & # 8221; = ano 2018, & # 8220; 236 & # 8221; = dia do ano 2018 3 = & gt; terceira compilação, executada no dia 236 no ano de 2018.

Analisar os detalhes da montagem de uma montagem Fabrikam feita sob encomenda agora revela meta dados corretos:

Também modifiquei o formato do número de compilação para ter mais informações de versão exibidas na execução de compilação.

Eu adicionei uma essência no GitHub para compartilhar o script do powershell. Observe que o script foi usado para experimentação e pode não estar pronto para ser usado para produção. Certamente, não há validação adequada e tratamento de erros. Use por sua conta e risco.

Também dê uma olhada em algumas postagens de blog inspiradoras semelhantes sobre versões do TFS Builds que me ajudaram a desenvolver o script powershell que funciona para o meu cenário.

Pós-navegação.

Deixe uma resposta Cancelar resposta.

Você está usando o termo Número de dia juliano incorretamente. O valor que você está referindo é chamado corretamente a Data Ordinal.

Eu atualizei do TFS 2018 para 2018, mas tenho problemas com o novo sistema de compilação, o novo agente não está tirando o mais recente do TFVC, compilações antigas do XAML e todas funcionam como esperado. Mesmo reparando o TFS, o problema não é resolvido. Parece ser um erro com o agente que não está funcionando corretamente.

Se eu manualmente fazer uma entrada para a pasta de compilação do agente antes de executar a compilação, defina as opções de limpeza como falso e ligue para o agente, tudo corre bem.

Além disso, se a pasta estiver vazia, a compilação falhará. Então, o que está acontecendo é que o agente não está conseguindo obter corretamente a versão mais recente do TFS, mesmo que mostre uma mensagem bem-sucedida no registro que não está baixando nada na pasta do mapa de destino.

Alguma ideia? Realmente aprecio o seu tempo!

Parece promissor, mas por que isso ainda é que as lojas precisam rolar suas próprias para & # 8230; certamente a maioria dos ISVs gostaria disso? Estou fascinado com o que o MS usa internamente.

Você poderia compartilhar seu postbuils. ps1? Quero saber como você registrou suas mudanças. Fyi, I & # 8217; m usando o controle de versão TFS.

Nenhum check-in de modificações. É o processo de compilação que está sempre a cargo para configurar o controle de versão. Não é necessário confirmar isso no controle de versão.

Coloquei seu PS em uma pasta de solução e configure o campo do nome de arquivo do script no passo de construção do powershell para apontar para ele, mas não executou. Ele diz Iniciar tarefa & # 8230; mas ainda não escreve mais nada no console e não atualiza a versão também. Mudei esse PS para o projeto e alterei o & # 8216; Copiar para o diretório de saída & # 8217; para & # 8216; copiar se mais novo & # 8217; e alterou o & # 8216; Script filename & # 8217; mas ainda não há diferença.

Eu segui o post do MSDN (https://msdn. microsoft/en-us/Library/vs/alm/Build/scripts/index) e ele está trabalhando, mas eu prefiro o PS que você colocou aqui como # 8217 ; aceitando a versão como um parâmetro. Eu acho que o problema é em como eu estou chamando seu. Você poderia compartilhar PreBuild. ps1?

O script do powershell que adicionei na essência do github está envolvido em uma função. Remova a função e funcionará bem & # 8230;

Confira este script que escrevi: ele aplica a versão dos arquivos de informações de montagem, mas também incrementa o número de compilação e verifica os arquivos de informações de montagem novamente no controle de origem:

Você tem uma solução para o indicador Missing build Quality in 2018 Builds? É uma questão importante em caso de gerenciamento do ciclo de vida. Como lidamos com isso em 2018?

Observe que usando yyDOY apresenta dois problemas de longo prazo:

& # 8211; O Century Bug (aka, Y2K), onde uma compilação em 2100 parecerá ser apresentada antes de uma compilação em 2099. Mas nós ganhamos, então, chegar tão longe, porque o & # 8230;

& # 8211; As compilações começarão a falhar em 2066, uma vez que o 66001 está além do limite UInt16.Max-1 para os componentes na versão Assembly e outros números.

As partes Maior e Menor da Versão da Assembléia e outros números são realmente uma decisão _design_ que deve ser implementada no código-fonte, não em tempo de implantação. Parece fazer mais sentido implementar esse design no código-fonte em vez do processo de compilação.

Nós ainda atualizaríamos o 3 * & amp; 4 partes durante o processo de construção, uma vez que é necessário um controle centralizado do incremento. Mas o Major & amp; Pequenas porções seriam retiradas do código fonte.

* A menos que você se mova para a versão semântica, que usa a 3ª porção como # 8220; Patch & # 8221; número. A escolha do & # 8220; Patch & # 8221; O número a usar também seria uma decisão _design_ a ser implementada no código-fonte.

Uma grande vantagem para esta abordagem é que você não precisa atualizar o parâmetro para o script PowerShell em sua Definição de Construção ao longo do tempo ou fornecer um valor correto para uma variável com cada requisição de compilação. As porções são definidas em código ou pelo próprio processo de compilação.

Em ALM com TFS / VSTS.

blogando sobre Gerenciamento do ciclo de vida do aplicativo com TFS / VSTS.

Estratégia de versão global e # 8211; AssemblyInformationalVersion.

Já ouvi falar de um terceiro atributo de versão (opcional) nos arquivos AssemblyInfo: AssemblyInformationalVersion. Não? Por favor leia!

Sem uma estratégia de numeração de versão metódica (assembly), a capacidade de determinar quais alterações foram incluídas em qual versão foi perdida. Na minha opinião, você sempre precisa saber exatamente quais arquivos de origem foram instalados em qual compilação e qual versão do software está atualmente implantada em um ambiente específico. Um sistema de numeração de versão aleatória cria confusão e logo ou mais tarde causará riscos de implantação. Vai se tornar um pesadelo para buscar os arquivos fonte exatos para reproduzir um bug da produção.

Todo o controle de versão de assembléias que usam o tempo de execução de linguagem comum é feito no nível de montagem. A versão específica de uma montagem e as versões de montagens dependentes são registradas no manifesto de montagem # 8217 ;. A política de versão padrão para o tempo de execução é que os aplicativos são executados apenas com as versões em que foram criados e testados, a menos que sejam substituídos pela política de versão explícita nos arquivos de configuração.

Cada projeto possui um arquivo AssemblyInfo que contém um atributo AssemblyVersion e um atributo AssemblyFileVersion.

AssemblyVersion: este é o número de versão usado pela estrutura durante a compilação e no tempo de execução para localizar, vincular e carregar as montagens. Quando você adiciona uma referência a qualquer montagem em seu projeto, esse é o número da versão que é incorporado. Em tempo de execução, o CLR procura a montagem com este número de versão para carregar. Mas lembre-se que esta versão é usada juntamente com nome, chave pública chave e informações culturais somente se as assembléias tiverem o nome forte assinado. Se os assemblies não tiverem um nome forte assinado, somente os nomes dos arquivos são usados ​​para carregar. AssemblyFileVersion: Este é o número de versão dado a um arquivo como no sistema de arquivos. É exibido pelo Windows Explorer. Nunca é usado por framework ou tempo de execução para referenciar.

Mas e quanto a essa diferença entre AssemblyVersion e AssemblyFileVersion? Muitas vezes, vejo que a mesma versão é aplicada a ambos os atributos e # 8230; mas por que esses dois atributos (diferentes) são fornecidos pelo Framework? O AssemblyVersion deve ser a versão pública de um aplicativo de software completo, enquanto o AssemblyFileVersion é mais a versão de um componente específico que pode ser apenas uma pequena parte do aplicativo inteiro. O AssemblyFileVersion é o melhor lugar para colocar informações de versão de compilação extra que podem ser importantes para corrigir componentes individuais de um aplicativo de software.

Siga as recomendações da Versão Semântica para determinar como o AssemblyVersion deve ser atribuído e incrementado. Para o AssemblyFileVersion, tendem a incluir informações de compilação específicas. Muitas vezes, você precisará criar (e testar) uma série de vezes uma versão SemVer específica do seu software.

Por exemplo: a versão 1 de um aplicativo de software poderia ter o AssemblyVersion configurado para 1.0.0 (todos os componentes), enquanto o AssemblyFileVersion dos componentes individuais poderia ser configurado para 1.0.15234.2 que se refere a um número de compilação exclusivo do sistema de compilação e é vinculado a uma determinada data e uma revisão: & # 8220; 15 & # 8221; = ano 2018; & # 8220; 234 & # 8221; = número do dia em 2018; & # 8220; 2 & # 8221; = segunda compilação processada nesse dia. Isso também permite posteriormente o patch de componentes individuais em produção com um similar AssemblyVersion (1.0.0), mas um AssemblyFileVersion diferente (1.0.15235.1).

Então, vamos tentar aplicar isso a um projeto de teste no Visual Studio e ver os detalhes da montagem após a construção do projeto & # 8230;

Agora você deve estar confuso! Por que a versão do produto exibe AssemblyFileVersion e onde o AssemblyVersion? O problema aqui é que um novo projeto do Visual Studio não inclui um atributo de terceira versão AssemblyInformationalVersion que se destina a representar a versão pública de todo o aplicativo de software. Observe que o CLR não se preocupa com esse terceiro atributo de versão (opcional). Em suma, as mesmas regras de versão semântica da AssemblyVersion devem ser aplicadas ao AssemblyInformationalVersion.

Aha! Isso parece muito melhor, certo? Agora, também é fácil extrair esses metadados de seus assemblies implantados e esta informação pode ser bem listada na caixa sobre do seu software. O único problema com esta abordagem é que o AssemblyFileVersion não inclui o & # 8220; patch & # 8221; número (versão semântica) do AssemblyVersion, mas isso pode ser ignorado com o fato de que o AssemblyFileVersion será exclusivo e pode ser vinculado a uma execução de compilação exclusiva no sistema de compilação. Esta maneira de trabalhar é minha interpretação pessoal de como o controle de versão pode ser aplicado corretamente em aplicativos de software complexos e não reflete as diretrizes oficiais da Microsoft. Meu objetivo aqui é fazer os desenvolvedores de software conscientes dos riscos potenciais de não ter uma estratégia de versão de versão clara.

Agora, esqueça manualmente a configuração das informações da versão nos arquivos AssemblyInfo e nunca libere o software de uma compilação Visual Studio local. Em um processo de compilação simplificado, gerar números exclusivos de compilação e versão são coordenados de forma centralizada. Para uma solução eficaz de problemas e rastreabilidade, é imperativo que as montagens geradas sejam carimbadas com um identificador exclusivo que possa ser facilmente rastreado até um número de compilação do sistema.

Em uma próxima publicação, falarei sobre como você pode alcançar essa estratégia global de versão com o novo sistema de compilação no TFS 2018.

Pós-navegação.

Deixe uma resposta Cancelar resposta.

O Real Semver permite uma tag de pré-lançamento como esta & # 8220; 1.2.4-beta04 & # 8221 ;. Semver também permite metadados como número de compilação, data, commit ou changeset como este & # 8220; 1.0.0 + 20180313144700 & # 8221 ;.

AssemblyInformationalVersion é o único campo que permite qualquer outra coisa que a notação de versão clássica, como 1.2.3.4. AssemblyVersion e AssemblyFileVersion só permitem a notação de versão estrita. E todas as partes estão limitadas a 65536. Eu acredito (porque por que precisamos de estranha notação para datas, certo?).

Você sugere a configuração AssemblyInformationalVersion e AssemblyVersion para a mesma versão, mas depois perdemos essa poderosa característica / idéia. E tudo o que está à esquerda é colocar uma certa data de representação do número de compilação no AssemblyFileVersion (desde que ele seja na forma de 1.2.3.4)

Talvez AssemblyInformationalVersion deve começar com AssemblyVersion, mas permitir que a tag e os metadados sejam anexados?

Ao empacotar um nupkg, o AssemblyInformationalVersion será usado. O que é ótimo porque dessa maneira você pode criar pacotes de pré-lançamento. Mas pode não ser fácil configurar tags de pré-lançamento para suas compilações automatizadas.

O mínimo que podemos dizer, é uma bagunça, é confuso e a estrutura não foi construída com tudo isso em mente. Para piorar as coisas, temos um trabalho real em vez de tentar descobrir esses detalhes inúteis 🙂

A informação de montagem global é uma boa idéia. Aliás, o Assembly Versioner e o Info Updater podem ajudar as versões de projeto / montagem do gerente e outras informações para todos os projetos / montagens em uma UI única:

O Visual Smarter tem muito mais recursos do que os dois acima.

Compartilhar uma versão comum de montagem / arquivo de informações é uma boa idéia se todas as assembléias / projetos devem ter a mesma informação / versão. Caso contrário, o Assembly Versioner e Info Updater podem vir a resgatar no último minuto:

O Visual Smarter tem muito mais recursos do que os dois acima.

Estratégias de ramificação com TFVC.

Neste artigo.

VSTS | TFS 2018 | TFS 2017 | TFS 2018 | VS 2017 | VS 2018 | VS 2018.

Você planeja adotar Team Foundation Version Control (TFVC) e está se perguntando como usar melhor as filiais? Não aprofundaremos as características de ramificação, pois estão bem documentadas na documentação e orientação do produto, mas exploraremos algumas estratégias de ramificação comuns para ajudá-lo a tomar a decisão certa.

Ao contrário dos ramos Git, que são repositórios escopo, os ramos TFVC são escopo do caminho e não como peso leve. Defina sua barra para criar ramos altos, para evitar o gerenciamento necessário para acompanhar ramos, recursos de armazenamento e resolução de conflitos de mesclagem. Considere ramificação somente se você tiver várias equipes trabalhando na mesma base de código ou precisar de isolamento para desenvolvimento ou lançamento.

A estratégia Main Only pode ser baseada em pastas ou com a pasta principal convertida em Branch, para permitir recursos adicionais de visibilidade. Você compromete suas alterações no ramo principal e, opcionalmente, indica os marcos de desenvolvimento e lançamento com rótulos.

RISCO: a mutabilidade e a falta de histórico com rótulos TFVC podem aumentar o risco de controle de mudanças.

Comece com a principal estratégia de ramificação, faça um ramo estrategicamente e adote outras estratégias para evoluir para estratégias mais complexas, conforme necessário.

Isolamento do desenvolvimento.

Quando você precisa manter e proteger um ramo principal estável, você pode ramificar um ou mais ramos de desenvolvimento do principal, dando-lhe isolamento e desenvolvimento simultâneo. O trabalho pode ser isolado em ramificações de desenvolvimento por recurso, organização ou colaboração temporária.

As mudanças feitas no ramo principal, devem ser integradas para a frente (FI) para o ramo dev e os conflitos de mesclagem foram resolvidos, antes que as alterações sejam revertidas (RI) de volta ao main. Para manter a mesma barra de qualidade em filiais, sempre crie e execute testes de verificação de compilação (BVTs) no dev da mesma forma que você está fazendo no main. Opcionalmente, combine esta estratégia de ramificação com outras estratégias aqui abrangidas.

NOTA: Com esta estratégia, é provável que as equipas mantenham o desenvolvimento do desenvolvimento em torno de sempre, potencialmente construindo um grande histórico de tickets de mesclagem.

Isolamento de características.

O isolamento de recursos é uma derivação especial do isolamento do desenvolvimento, permitindo que você ramifique um ou mais ramos de recursos da principal, como mostrado, ou de seus ramos de dev.

Quando você precisa trabalhar em um recurso particular, pode ser uma boa idéia criar um ramo de recursos.

Você deve manter a vida útil do recurso e o ramo de recurso associado de curta duração. A integração direta (FI) muda do ramo pai com freqüência, mas inverte a integração (RI) de volta para o pai somente quando alguns critérios de equipe acordados, por exemplo, definição de feito, são atendidos. A recuperação dos recursos no main pode ser dispendiosa e pode reiniciar o teste.

Liberar o isolamento.

O isolamento de lançamento introduz um ou mais ramos de liberação do principal, permitindo o gerenciamento de lançamento simultâneo, lançamentos múltiplos e paralelos e instantâneos precisos da sua base de código ao tempo de liberação.

Quando sua base de código possui o primeiro candidato a liberar ou a versão está pronta para ser bloqueada, pode ser um bom momento para criar um novo ramo para a versão.

Nunca encaminhe integrar (FI) dos ramos de lançamento principal e de bloqueio usando permissões de acesso, para evitar modificações não intencionais em uma versão. Os remendos e correções rápidas feitas no ramo de liberação podem ser integrados de forma reversa (RI) de volta ao ramo principal.

NOTA: Nenhum dos cenários de ramificação é imutável, razão pela qual você percebe os hotfixes de emergência executados em ramos de lançamento. Evolua cada estratégia para combinar com seus requisitos, sem perder de vista a complexidade e o custo associado.

Manutenção e liberação de isolamento.

A estratégia de manutenção e isolamento de lançamento introduz os ramos de manutenção, permitindo o gerenciamento simultâneo de serviços de service packs e instantâneos precisos da base de código no serviço e tempo de liberação.

Considere esta estratégia se você precisar de um modelo de manutenção para que os clientes atualizem para a próxima versão principal e pacotes de serviço adicionais por versão.

Como o isolamento do lançamento, os ramos de isolamento e liberação de serviço são criados quando a versão está pronta para ser bloqueada. Nunca encaminhe integrar de main para manutenção, nem de manutenção para liberação, e bloquear o ramal de liberação para evitar modificações. Alterações no serviço futuro podem ser feitas no ramo de manutenção.

Crie novos ramos de manutenção e lançamento para lançamentos subseqüentes, se você precisar desse nível de isolamento.

Manutenção, Hotfix, Liberação de isolamento.

Embora não seja recomendado, você pode continuar evoluindo as estratégias, introduzindo ramos de hotfix adicionais e cenários de lançamento associados.

Neste ponto, você explorou com sucesso alguns dos cenários de ramificação TFVC comuns. Você pode evoluí-los ou investigar outras estratégias, como ativação e desativação de recursos, para determinar se um recurso está disponível em tempo de execução.

Por que os ramos devem ser de curta duração?

Ao manter os ramos de curta duração, os conflitos de fusão são mantidos ao menor número possível.

Por que apenas ramo se for necessário?

Para abraçar o DevOps, você precisa confiar na automação de compilação, teste e implantação. A mudança é contínua, freqüente e combina operações mais desafiadoras, pois os conflitos de mesclagem geralmente requerem intervenção manual. Recomenda-se, portanto, evitar a ramificação e confiar em outras estratégias, como a alternância de recursos.

Por que remover ramos?

Seu objetivo deve ser obter as mudanças de volta ao principal o mais rápido possível, para mitigar as consequências da fusão de longo prazo. Os ramos temporários, não utilizados e abundantes causam confusão e despesas gerais para o time.

Pode uma base de código ser ramificada em projetos de equipe?

Sim, mas não é recomendado, a menos que as equipes compartilhem fonte e não compartilhem um processo comum.

E a estratégia de promoção do código?

A estratégia de promoção do código parece uma relíquia da era do desenvolvimento da cachoeira. É tipicamente com ciclos de testes longos e equipes separadas de desenvolvimento e teste. A estratégia já não é recomendada. Consulte a orientação de ramificação para obter mais informações.

Ao fundir o dev para o ramo principal, por que as alterações não são detectadas?

Você provavelmente ignorou as alterações em mesclagens anteriores, por exemplo, usando a opção de manter a resolução de conflito de origem. Consulte fusão do ramo de desenvolvimento para principal: não houve alterações para fundir detalhes.

Existem semelhanças entre estratégias TFVC e Git?

A estratégia de ramificação do Isolamento de Recursos do TFVC é semelhante aos ramos do tópico Git.

Autores: Jesse Houwing, Marcus Fernandez, Mike Fourie e Willy Schaub.

(c) 2018 Microsoft Corporation. ÃїTodos os direitos reservados. Este documento é fornecido "como está". & quot; Informações e opiniões expressas neste documento, incluindo URL e outras referências de sites da Internet, podem mudar sem aviso prévio. Você corre o risco de usá-lo.

Este documento não fornece qualquer direito legal a qualquer propriedade intelectual em qualquer produto da Microsoft. Você pode copiar e usar este documento para fins internos de referência.

Estratégias de ramificação TFVC eficazes para DevOps.

Neste artigo.

Você está planejando abraçar o DevOps usando o Team Foundation Version Control (TFVC)? Você provavelmente tem algumas perguntas, como:

Como faço para decidir sobre a estratégia de ramificação certa? Existe uma estratégia eficaz para o DevOps? Como aceito aplicativos com versões únicas ou múltiplas?

(Com base em uma entrevista com Abel Wang e Steve St Jean)

O TFVC é um sistema de controle de versão centralizado para manter o código e tornar as equipes mais efetivas, fornecendo colaboração e consistente compartilhamento de códigos, publicação e revisão de recursos.

Mantenha simples!

Ao adotar uma estratégia de ramificação efetiva, você deve:

Fomentar uma cultura DevOps Promover fluxo de colaboração e aumento da produtividade Permitir que as equipes passem mais tempo desenvolvendo e menos tempo gerenciando o código.

Para abraçar o DevOps, é importante manter sua estratégia de filial simples e se esforçar para a alta qualidade. Algumas sugestões:

Comece com uma estratégia simples e evolua conforme necessário Use convenções de nomenclatura consistentes para recursos de ramos / nome de usuário / descrição para o trabalho realizado por um indivíduo - exemplo, características / sandra / sdk-java bugfix / nome de usuário / bugid para trabalho feito especificamente para um erro de engenharia - exemplo, versões / versão de bugfix / takashi / 707 para versões planejadas - exemplo, lançamentos / V1.00 Com frequência, inverter integrar (RI) e fundir em seu ramo principal Incentivar revisões de código consistentes - lixo, lixo Executar uma pipeline CI / CD, Usando: checkins fechados Testes automatizados.

Comece com uma estratégia de ramificação simples.

Crie uma estrutura de controle de origem que identifique as unidades de lançamento que podem ser enviadas. O conceito de unidades liberáveis ​​é uma peça fundamental desta estratégia, que Steve St Jean descreve da seguinte maneira:

A unidade física de versão e entrega. A unidade primária para suportar os modelos de ramificação e lançamento. Pode estar no nível Suite, Application ou Component. Para as Suites, todas as aplicações devem ser reproduzidas e corrigidas. Por exemplo, o Microsoft Word e o Excel fazem parte da unidade liberável do Microsoft Office Suite, mas o Visio não é como ele pode liberar ou corrigir independentemente do resto do Microsoft Office Suite. No TFVC este seria o nó raiz do nó do projeto da equipe. Pode ser equiparado a um repo no Git.

Normalmente, você começa a ter que suportar apenas uma versão de produção, com correções de defeitos paralelos e desenvolvimento de novos recursos para versões futuras. Exemplos típicos incluem sites, linhas corporativas de aplicativos de negócios e ferramentas interinas.

Comece com a estratégia de ramificação simples, principal somente.

Automatize sua compilação para disparar com cada check-in para o ramo principal, execute testes automatizados e, se for bem sucedido, implemente a versão em um ambiente de desenvolvimento (dev).

When you complete a release cycle, create a release branch. Use the release branch to stabilize the release, and continue development for your next version in main. Reverse integrate (RI) and merge validated bug fixes with your main branch frequently, to minimize your overall technical debt.

Automate your build to trigger with every checkin to the release branch, run automated tests, and use release management to deploy to a development, quality assurance, user acceptance, staging, and finally your production environment.

When version 2 becomes the Release Candidate you can update your existing RC build definition to point to the V2.00 branch and it will now build and release just as V1.00 did when it was the current version.

Expand branching strategy as needed.

When the need arises to support more than one production version, for example a commercial solution such as Word, you can expand your simple branching strategy.

For every completed release cycle you need to support, create a new release branch and continue next version development in main, using feature isolation. Take note of the reverse integration (RI) merges from v1.0 and v2.0 to main , which represent bug fixes that are released to production.

So, by using a simple branching strategy and adopting a consistent naming convention , you'll be able to support applications that have one or more supported releases, continuous development of new features, and continuous delivery of value to your users.

Checklist and lessons from the field.

Keep it simple and expand branching complexity as needed Organize your code into shippable units Use a consistent naming strategy for your branches Build with every check in Create a CI/CD pipeline using gated checkins and automated testing.

Lessons from the field - things to avoid.

Avoid going branch crazy! merging changes comes with complexity and a cost there's no need to have a separate branch per environment Avoid using cherry-picking to get your code to production Do not attempt to solve people or process problems with tools.

Reference information.

Authors: Sergio A Romero | Find the origin of this article and connect with the ALM Rangers here.

(c) 2017 Microsoft Corporation. Todos os direitos reservados. This document is provided "as-is." Information and views expressed in this document, including URL and other Internet Web site references, may change without notice. You bear the risk of using it.

This document does not provide you with any legal rights to any intellectual property in any Microsoft product. You may copy and use this document for your internal, reference purposes.