Como você lida com a versão em um projeto de vários lados?

Eu sei que é uma pergunta ampla, então tentarei ser o mais específico possível. Esta questão é mais uma questão "organizacional" do que técnica.

Temos um projeto de vários lados com estes componentes principais:

• Um servidor que hospeda a lógica comercial principal (modelos de dados)
• Um backoffice para clientes que usa a lógica de negócios principal
• Uma API de aplicativo (REST) ​​que também usa a lógica de negócios principal
• Existem aplicativos para smartphone (iOS e android) usando a API do aplicativo
• Há outro aplicativo para tablet (android) diferente do smartphone, que usa a mesma API do aplicativo.

Em breve, estarei em produção com clientes ativos. E, como em qualquer projeto, precisarei manter todos os diferentes componentes ao longo do tempo. Isso significa que todos os itens a seguir podem ser atualizados:

• o código da lógica de negócios principal no servidor (usado pelo back-office, pela API e, como efeito colateral, pelos aplicativos móveis)
• a própria API (usada pelos aplicativos para smartphone e tablet)
• todos os aplicativos móveis (via appstore / googleplay)

Obviamente, as partes do servidor (código da lógica de negócios principal e código da API) podem ser alteradas imediatamente por mim. No entanto, os novos aplicativos móveis devem ser baixados pelos clientes na appstore / googleplay, e não tenho certeza se eles estão atualizados.

Você poderia fornecer alguma orientação, dicas de boas práticas, para tornar essas atualizações suaves e sem riscos para o cliente?

Qual componente eu preciso "versão"? Como garantir que tudo funcione mesmo que o cliente não atualize seu aplicativo móvel? Devo forçá-lo a atualizar para facilitar meu trabalho?

Em uma palavra, como devo me organizar para fazer meu projeto de várias faces viver com o tempo?

Como você não pode controlar quando os aplicativos móveis serão atualizados para uma nova versão, é necessário fazer a versão pelo menos da API REST. Caso contrário, será impossível fazer alterações incompatíveis com a versão anterior dessa interface.

Além da API REST, é uma boa idéia versão também as outras interfaces de comunicação que passam por uma interface de rede. Dessa forma, você também não é obrigado a atualizar todos os clientes de backoffice ao mesmo tempo que os servidores e pode implementar uma migração gradual para uma nova versão com um período de "teste beta".

Além de controlar a versão das interfaces de comunicação, você também deve tentar tornar as alterações compatíveis o máximo possível. Idealmente, você pode lançar uma nova versão da interface que ainda suporte totalmente os clientes antigos, para que eles não notem que nada mudou.

Este post faz um ponto interessante sobre sua pergunta.

De uma maneira mais prática, se você tiver 3 componentes:

• 2 consumidores: um front-end e um aplicativo móvel
• 1 provedor de API: um back-end

Você pode usar o esquema de versão típico Mmp (Major.minor.patch) para cada um, mas, no seu URL de back-end, pode colocar algo como http://youhost/M.m/resourceURI.

À medida que você evolui e as alterações na API não afetam seu contrato com os consumidores, você mantém o M.mque está no URL. A partir do momento em que você faz uma alteração no BackEnd que afeta seus consumidores (seja uma mudança de comportamento ou um objeto diferente), você usa a M.m+1, M+1.m+1ou M+1.m.

A maneira de manter as coisas funcionando é implantar o novo Back-End simultaneamente com o antigo, enquanto seus usuários instalam os novos consumidores e descontinuam lentamente a API mais antiga.

Você pode ver uma resposta muito melhor do que a minha aqui: Versioning API REST on Stackoverflow

Eu recomendo que você instale um servidor de integração contínua, conecte-o ao seu repositório de códigos e a um repositório de snapshot / release e automatize suas compilações. Isso terá várias vantagens:

1. Cada componente será versionado quando for lançado. Isso inclui bibliotecas de baixo nível, bem como seus produtos finais.
2. Cada confirmação de código acionará uma compilação de instantâneo. Isso ajuda a manter seus desenvolvedores honestos, especialmente se você usar o recurso para enviar um email ao culpado que quebrou a compilação.
3. Cada compilação pode executar testes de unidade. Isso melhora significativamente a qualidade do código.
4. Cada versão será marcada, portanto, se uma correção de produção for necessária, é fácil ramificar da tag e fazer a correção.
5. Você precisará manter algum tipo de registro de compatibilidade. (por exemplo, o BackOffice 1.0.23 é compatível com a API REST 2.0.267 etc.). Não conheço uma ferramenta que ajude nessa área.

Minha experiência foi com ferramentas de código aberto: SVN, Maven 2, Jenkins e Nexus, mas existem alternativas para tudo isso.

Não subestime o tempo de aprendizado para acelerar sua equipe. Mas, uma vez que estão atualizados, nunca mais voltarão.

Para uma equipe relativamente pequena para desenvolvimento e implementação, o modelo de compatibilidade do Cliente N-1, conforme empregado pelo IBM Jazz, pode funcionar muito bem

Tente manter clientes e servidores no mesmo número de versão. [Em vez de gerenciar uma matriz de versões independentes e suas compatibilidades]

Faça uma política para que a versão do cliente Xyy funcione com todas as versões de servidores acima do Xyy, mas inferior ao X + 2.0.0

Para uma versão do servidor 4.0, idealmente deve haver uma versão do cliente 4.0 para cada tipo de cliente. No entanto, a compatibilidade deve ser mantida para permitir versões ligeiramente diferentes de clientes e servidores.

Um cliente versão 4.x deve ser compatível com os servidores versão 4.xe acima, mas abaixo de 6.0; Um servidor 4.x deve ser compatível com todos os clientes versão 3.0 e superior, mas menor ou igual a 4.x

Dessa forma, você pode atualizar uma versão no servidor sem se preocupar com o lançamento imediato de novas versões dos clientes, mas terá apenas uma janela de compatibilidade bem definida para manter.

Ref: IBM Jazz Model [ https://www.ibm.com/support/knowledgecenter/en/SSYMRC_6.0.0/com.ibm.jazz.install.doc/topics/c_n-1.html]

Primeiro, vamos começar enquadrando o problema de maneira um pouco diferente. Você perguntou quais peças de software você precisa "versão". Versão é um termo sobrecarregado no CS e pode significar cerca de 100 coisas diferentes. As principais coisas que eu consideraria são:

1. Controle de versão - O controle de versão é uma ferramenta de gerenciamento de configuração que ajuda a acompanhar os instantâneos e o histórico do seu desenvolvimento. TODO O CÓDIGO DEVE ESTAR SOB CONTROLE DE VERSÃO. Não me importo se apenas os scripts de conveniência adicionados à sua pasta bin, qualquer coisa que valha a pena gastar tempo escrevendo valer os dois segundos a serem adicionados a um software de controle de revisão.
2. Gerenciamento de configuração - Como controle o que está na compilação. Todo software deve ter algum grau de gerenciamento de configuração. Eu gosto de descrever aos gerentes a diferença entre controle de versão e gerenciamento de configuração, pois o controle de versão é apenas uma ferramenta para rastrear o histórico de desenvolvimento, enquanto o gerenciamento de configuração é as diretrizes de como criamos o histórico e fazemos coisas como decidir o código é bom.
3. Versão do software - atribuindo nomes às liberações de código. É o que muitas pessoas se apegam quando vêem o problema pela primeira vez, porque costumam ver o "MineSweeper 7.1.29290149210" ou qualquer outra coisa que compram, mas honestamente, acho que essa é a parte menor de um problema muito maior. Para ser honesto, basta usar o hash gerado por 1 e não se importar tanto com o que não é legível por humanos.

Então, como é o mais nebuloso e mais interessante para mim, vou focar no # 2. Não existe uma solução única para o gerenciamento de configurações. Regras que funcionam bem para uma equipe de 2 ou 3 podem ser muito frouxas para manter a sanidade em um projeto que leva centenas de trabalhadores. Regras que funcionam com a grande equipe podem exigir muita sobrecarga para a pequena equipe. Você provavelmente precisará criar algo próprio para criar algo, mas eu usaria a lista a seguir como forma de desenvolver as especificações para o seu sistema de gerenciamento de configuração:

1. Como posso acompanhar as versões (e os problemas associados a elas) que estou apoiando no mercado?
2. Como vou decidir quais caminhos de desenvolvimento estão prontos para lançamento nos sistemas de produção? (Também pode estar pronto para qualquer outra etapa do processo)
3. Quem deve controlar / gerenciar a configuração do sistema? Qual é o fluxo de trabalho para adicionar código a ser distribuído a outros desenvolvedores?
4. Como vou controlar a interação entre as partes que interagem? Como saberei se a alteração de uma peça interromperá o restante do sistema?
5. Como vamos melhorar nosso sistema de gerenciamento de configurações ao longo do tempo.

Precisa de ajuda para responder às perguntas acima? Você provavelmente deve contratar um consultor ou gerente de engenharia de software ... respondendo que possa preencher os livros didáticos e esteja fora do escopo desse tipo de fórum.