Estratégia de versão

Versão.
Crie uma linha de produtos.
A versão é a prática de oferecer uma gama de produtos baseados em um produto principal. A versão pode gerar novos lucros e crescimento de duas formas distintas. Primeiro, oferecendo novos produtos para atender clientes com necessidades exclusivas. Drivers em climas quentes (que não requerem um grande número de amplificadores de arranque para iniciar um veículo) podem comprar a bateria de automóvel DieHard South de $ 79.99 da Sears. A Sears também oferece uma versão de platina de US $ 179,99 para drivers em áreas frígidas que precisam de uma bateria mais poderosa (amplificadores de inicialização mais altos). Em segundo lugar, oferecer produtos bons, melhores e melhores permite aos clientes escolher quanto pagar (a escolha de um consumidor revela sua verdadeira avaliação). O McDonald's vende US $ 1 McDoubles e US $ 3,59 Quarter Pounders. Na maior parte, os ingredientes nesses dois sanduiches são semelhantes. Os clientes sensíveis ao preço adquirem o McDoubles, enquanto aqueles com orçamentos maiores escolhem preços trimestrais de preço premium.
A criação de um produto versionado pode ser implementada através de três métodos principais:
Premium (maior qualidade, acesso garantido, mais rápido, serviço prioritário, baixa franquia / melhor cobertura). Descartado (menor qualidade, mais restrições, fora de pico, marca privada, desagregação, franquias mais elevadas e benefícios mais baixos). Conheça as necessidades exclusivas dos clientes (tamanho do pacote, garantias estendidas e aprimoradas, clubes mensais, agrupamento, plataformas, uso diferente).
A versão atrai novos clientes (com necessidades exclusivas), além de obter diferentes margens de lucro para diferentes clientes. Os produtos descontraídos oferecem descontos, enquanto os prémios são derivados de versões topo de linha. O aumento dos lucros dessas versões premium de alta margem e novos clientes (com necessidades exclusivas, bem como aqueles que compram versões com preços baixos) são um componente chave da campanha de arrecadações de preços de todas as empresas.

Micro serviços - Estratégias de controle de versão.
Identificando os problemas com o controle de versão e explorando possíveis soluções.
ОјServiços são quadril! Já estiveram por um tempo. Mas, embora uma abordagem modulável e flexivelmente forte, tende a tornar os projetos mais fáceis de manter, ele também traz o próprio conjunto de problemas. Nesta publicação do blog eu quero mergulhar em um desses problemas; controle de versão.
Esta publicação do blog vem com o código de exemplo.
Atualização: também criei uma implementação mais profunda desse padrão de adaptador no Spring Boot. Leia tudo sobre isso aqui!
Introdução.
Alguns anos atrás, trabalhei em um projeto que usava uma abordagem ОјService (ish). Enquanto o código estava bem escrito e uma completa alegria para trabalhar no controle de versão, os serviços não foram levados em consideração. Para a serialização entre serviços, utilizou-se uma camada RPC doméstica baseada em Netty e Kryo. Era rápido e fácil de usar, mas tinha um enorme problema: os serviços não podiam se comunicar entre si, a menos que as classes serializadas tivessem a mesma estrutura e usassem as mesmas versões (ou pelo menos compatíveis) do Kryo.
Uma vez que também não houve negociação de versão entre os serviços, havia apenas uma solução: implantar todo o ecossistema como um grande monólito. E isso é algo muito importante com um microfone: um monólito modular em vez de uma verdadeira arquitetura ОјService onde você não tem os benefícios de uma arquitetura ОјService (agilidade: você deve poder trocar um dos serviços) enquanto você ainda tem as desvantagens de uma arquitetura ОјService (principalmente você perde a capacidade de fazer atualizações transacionais).
É por isso que, se você decidir ir para uma arquitetura ОјService, você precisa descobrir e decidir sobre uma estratégia para usar e cumpri-lo.
Formato de dados.
Deixe começar com um formato de dados. No exemplo da introdução usamos um formato binário que, apesar de ser pequeno e rápido, teve um grande problema em que era difícil ou quase impossível tornar compatível com versões anteriores. Isso foi um erro. Embora existam formatos binários que permitem a compatibilidade com versões anteriores (Protobuf, Smile) em nossos exemplos, vamos usar o JSON. Se uma nova versão de protocolo apenas adiciona campos, ela deve ser tratada muito bem por clientes mais antigos.
Versões de protocolo.
Eu mencionei a versão do protocolo e este é o segundo componente importante que você precisa decidir: a sua numeração de versão do protocolo. Na verdade, você pode usar apenas um número inteiro que você colida sempre que uma nova versão quebra a compatibilidade. Uma vez que o seu protocolo é compatível com versões anteriores sempre dentro de uma versão, não existe necessidade aguda de um & lt; major & gt;. & Lt; minor & gt; esquema de versão.
Certifique-se também de que o cliente sempre diz ao serviço qual versão de protocolo espera. Quando o cliente não criou um erro ao invés de fazer a suposição implícita, o cliente quer uma certa versão: isso diz ao desenvolvedor que ele deve sempre incluir a versão. Você também precisa dessas informações para saber quantos clientes ainda não estão atualizados para avaliar o impacto da depreciação de versões antigas.
Estratégias.
Então, agora que decidimos um formato de dados e uma estratégia de controle de protocolo, podemos agora aplicar isso e decidir sobre uma estratégia. Nós usaremos uma API "Ordem" muito simples para uma loja na web como um exemplo. Nós apenas temos uma única chamada GET que retorna uma ordem com os itens do & # 8217; s com base nela & ID # 8217; s ID.
Temos duas versões, 1 e 2, que não são compatíveis. Resposta da Versão 1:
Como você pode ver, cometemos alguns erros nesta resposta. O campo customerLastName está com erros ortográficos e o orderTotal em centavos é inconsistente com os preços dos itens de ordem sendo números decimais. Então corrigimos isso no formato versão 2:
Muito melhor! Além disso; completamente incompatível!
Versão de versão baseada em roteamento.
Uma estratégia relativamente simples que funciona bem para API & # 8217; s que estão externamente expostos é simplesmente ter a versão no URL da rota. Assim, a primeira versão do nosso cliente GET / v1 / order / 1 e as versões mais recentes baseadas em nossa nova API exigiriam GET / v2 / order / 1. Teríamos então a versão antiga da API em execução na porta 8001 e a nova versão na porta 8002.
Um proxy reverso (como Nginx) simplesmente roteia a solicitação (removendo o bit / vN) para o serviço correspondente.
Esta é uma estratégia que é relativamente simples de implementar (mesmo em retrospectiva), mas faz algumas com algumas desvantagens. O primeiro é, obviamente, que você precisa manter as versões antigas dos serviços em paralelo. Uma nova versão do nosso Servidor de Pedidos pode, por exemplo, alterar o banco de dados de tal forma que as versões antigas podem acessar os dados mais.
Outra questão é que, embora isso funcione bem para serviços expostos externamente, estamos falando sobre ОјServices aqui. Você tem muitos serviços que se comunicam entre si que todos teriam que passar por um proxy reverso.
Ver versão baseada.
Outra abordagem é mover a lógica de manipulação de compatibilidade para trás para o código. Na minha opinião, isso faz sentido: o desenvolvedor que fez a modificação tende a saber como ser compatível com versões anteriores.
Nosso código de exemplo é baseado no Spring Boot (embora conceitualmente, qualquer linguagem e framework possam ser usados) que internamente usa Jackson para serialização JSON. Jackson tem o conceito de "pontos de vista". Um cenário comum desses tipos de pontos de vista é que você deseja expor apenas uma parte dos detalhes de uma Pessoa para usuários não autorizados e mais informações para usuários / usuários autorizados. Semelhante a como, por exemplo, o seu e-mail no seu perfil do Facebook pode ser disponibilizado apenas para seus amigos íntimos.
Mais informações sobre Jackson Views aqui.
No exemplo, criei um controlador que mostra as duas abordagens. Deixe primeiro olhar o construtor primeiro:
Como você pode ver, preenchemos nosso "banco de dados" com uma única Ordem e também configuramos os mapas de visualização e adaptador. Uma "visão", conforme explicado no artigo vinculado, é apenas qualquer classe. Ele usa classes em vez de strings simples para que ele possa usar a herança de objeto básico.
O adaptador é uma função simples que mapeia uma ordem para um objeto MappingJacksonValue.
Eu também explicarei o método de utilitário getProtocolVersion:
Este método, usado por ambos os métodos de controle de versão, é como obtemos a versão do protocolo do cabeçalho fornecido pelo cliente. Se não for fornecido, responderá com um código de status 400.
A fonte do controlador é relativamente simples:
O que você provavelmente observa é que não devemos retornar um objeto "Ordem" do controlador como você normalmente, mas use um invólucro Jackson MappingJacksonValue em vez disso. Isso nos dá a flexibilidade para fornecer uma visão diferente com base na versão.
O método getOrderView simplesmente procura uma classe de exibição com base na versão ou retorna a visualização Versão2 padrão.
Agora configuramos a visão, vamos ver como a compatibilidade com versões anteriores é tratada. Isso é tratado na classe OrderSerializer, que é um serializador padrão de Jackson:
A razão pela qual eu usei um serializador em vez de apenas usar a funcionalidade de exibição padrão é porque ele pode manipular serializar uma propriedade com um nome diferente muito bem.
Como você pode ver, a exibição é fornecida ao serializador através do método serializerProvider. getActiveView () e você pode executar sua lógica de compatibilidade com base nisso. A desvantagem é que você tem que fazer muito trabalho manual.
Versões baseadas em adaptadores.
Um método que é, na minha opinião, um pouco mais elegante é a aplicação do padrão de design do Adaptador. Aproveitamos a natureza vagamente acoplada de ОјServices e, com base na versão do protocolo, devolva um objeto completamente diferente. Nesta abordagem, também usaremos o cabeçalho X-Protocol-Version fornecido pelo cliente.
Então, deixe-nos dar uma olhada na segunda rota:
O controlador passa o Order encontrado para um método de adaptação que procura a função de mapeamento (yay para Java 8!) E aplica-o a uma ordem. Como você viu no construtor para a versão 1, envolve a Ordem em um objeto OrderV1 que então será serializado por Jackson na saída. Se parece com isso:
Este é um adaptador típico: ele não contém nenhum dado em si; Ele apenas "adapta" a nova versão para uma interface antiga. Desta forma, toda a lógica importante ainda está na classe Order e apenas a "lógica do adaptador" está contida no adaptador.
O que eu gosto dessa solução é que é claro e fácil de ler, não requer muitos códigos (tenha em mente que você só precisa de adaptadores para classes que "quebram" entre as versões) e também é fácil de se adaptar ( heh) para diferentes métodos de serialização. Este mecanismo pode ser facilmente aplicado, por exemplo, à serialização e / ou aos serviços do Protobuf com as filas Kafka, por exemplo.
Conclusão.
Eu mostrei algumas abordagens nesta postagem do blog e cada uma delas tem seus nomes e contas profissionais. A lição importante no entanto é que o controle de versão deve ser parte de sua arquitetura e não apenas um tipo de reflexão posterior. Apenas para a API externa, é realmente importante, mas com a malha fina de serviços interconectados que você vê em uma arquitetura ОјService. É preciso uma decisão para decidir sobre uma estratégia.
E não importa qual estratégia você escolher, você deve certificar-se de que você sempre se comunica claramente (no URL, o nome do seu tópico Kafka ou um cabeçalho), qual é a versão do protocolo esperado. Sem ele, é impossível rotear, impossível escrever adaptadores e impossível mesmo saber quais versões estão "lá fora" na natureza.
Espero que tenham gostado desta publicação tanto quanto gostei de escrever. Sinta-se à vontade para brincar com o exemplo e deixe-me saber se você tem comentários ou perguntas!
Direitos autorais e cópia; Niels Dommerholt 2017 - Assado com JBake - Template Clean Blog.

Estratégia de versão
Obter através da App Store Leia esta publicação em nosso aplicativo!
Uma boa estratégia para implementar um sistema de versão.
Eu tenho lutado com o software de versão por um tempo agora. Eu não estou falando sobre uma convenção de nomenclatura, estou falando sobre como realmente aplicar uma versão em um sistema de compilação até o final de uma versão.
Eu geralmente uso major. minor. maintenance - [release type], ou seja, 1.0.2-rc1.
O problema é gerenciar o número da versão. Eu tentei muitas maneiras (colando-o em um arquivo de compilação, um arquivo de propriedades, um banco de dados, etc., etc.), mas não encontrei nada que realmente funcione bem.
Pergunto-me se alguém tem boas ideias sobre isso. Além disso, perguntando-se como as pessoas lidam com a liberação de uma versão. ou seja, se eu liberar / implantar a versão 1.0.0-rc1, os erros encontrados nesta versão, então, faça o login no 1.0.0 (a próxima versão de produção).
A Microsoft usa & lt; major & gt;. & Lt; minor & gt;. & Lt; patch & gt; - & lt; build number & gt; (ou uma variação).
Eu gosto de usar & lt; major & gt;. & Lt; minor & gt;. & Lt; buildnumber & gt;
Onde eu estou trabalhando, usamos o sistema Maven: artefato [-major-menor-revisão] [- INSTANTÂNEO] que nos permite desenvolver versões "em andamento" que mudam em um momento de aviso (SNAPSHOT) e aqueles que foram lançados formalmente . Alguns exemplos são:
-services-1.0.0-SNAPSHOT. jar - web-2.3.11.war crm-2.5.0.ear.
Se tiver SNAPSHOT nele, não passou o conjunto completo de testes ou é apenas uma experiência de desenvolvedor. Se não tiver o SNAPSHOT, é um candidato à liberação. Nós mantemos um repositório de candidatos de lançamento e o mais recente é enviado para implantação uma vez que os testadores estão felizes com ele.
Tudo isso pode ser gerenciado com algumas entradas simples em um arquivo de compilação sob o Maven. Veja o tutorial Maven2.
Este é provavelmente um post morto agora, mas vou adicionar meus dois centavos de qualquer maneira. Eu sou de opinião que os números de compilação deveriam significar algo para todos os que vêem isso. Então eu pessoalmente acho que esta é uma boa maneira de nomear versões:
major. minor. patch. revision - e. 1.1.4.2342.
Os números principais / menores são bastante auto-explicativos. Mas, na perspectiva do terceiro número, ainda precisa significar algo para o cliente. Lancei esta nova versão para você, Sr. Cliente, mas não valia a pena um novo número menor, já que acabamos de corrigir alguns erros. Então aumentamos o número do patch.
O 4º número geralmente significa absolutamente nada para o cliente, então você também pode torná-lo útil para você e para qualquer outra pessoa da sua empresa que o veja. Então, para nós, esse número é o número de revisão SVN. Ele nos diz exatamente qual revisão foi responsável por essa versão para que possamos retirá-la a qualquer momento para recriá-la. O código de ramificação obviamente obtém isso também, mas não para 100% de certeza.
Além disso, outra vantagem com um número de versão totalmente numérico é que ele se integra facilmente em quase todos os sistemas de compilação contínua.
De qualquer forma, são meus dois centavos.
+1 na solução Jira / Bamboo. A única informação adicional sobre a compilação que eu incluíria (para meus propósitos) é a versão do Subversion, embora a operação de marcação seja 80% do que eu quero.
A manutenção manual das informações de versão / versão é uma dor real. Deixar o JIRA dirigi-lo é uma ótima idéia.
Na pergunta final, sobre onde os erros / defeitos são registrados e liberando uma versão:
O defeito / Problema é registrado contra o lançamento onde ele aparece. Um defeito no 1.0.0-rc1 é registrado contra 1.0.0-rc1 A JIRA (ou talvez adicionamos) um campo 'Fix-For' que teria a versão planejada, neste caso 1.0.0 Se o defeito / problema for suficientemente grave, pode ser necessário adicionar outra versão 'rc'. O lançamento é feito quando não há defeitos / problemas críticos pendentes eo cliente (ou gerenciamento) concorda que quaisquer problemas remanescentes podem ser diferidos.
A beleza de gerenciar isso através do JIRA é que a adição de lançamentos, geração de logs de mudanças, etc. é automatizada bastante bem.
Nós também usamos & lt; major & gt;. & Lt; minor & gt;. & Lt; buildnumber & gt; e nós gerenciamos isso com CruiseControl / () no nosso servidor de compilação. E use Wix e CruiseControl Config para gerenciar os principais números menores - ainda assim incrementar esses com a mão - mas o número da compilação acontece automaticamente quando no servidor de compilação. Você poderia configurar uma regra de um incremento de maior / menor automaticamente também. Eu acredito - nós simplesmente gostamos de fazer isso manualmente para que seja preciso um pensamento consciente por um dev quando é hora de nomear um nível de lançamento particular.
Major e Menor são definidos por nós, incrementando-os manualmente como acharmos adequados.
BuildDateNumber é o número de meses desde o início do projeto multiplicado por 100, mais o número do dia do mês atual.
DailyBuildNumber é incrementado para cada compilação após a meia-noite a cada dia, começando em zero.
Por exemplo. 4ª versão da versão 5.2 em 10 de julho, onde o projeto começou 1 de janeiro desse ano, teria o número da versão.
Isso é tudo calculado para nós pela tarefa Versão em Nant.
Isso mantém os números de versão únicos e também nos permite calcular rapidamente quando uma instalação foi criada.

Estratégia de versão
Obter através da App Store Leia esta publicação em nosso aplicativo!
Qual é a sua estratégia de versão do aplicativo? [duplicado]
Esta questão já tem uma resposta aqui:
Eu estaria interessado em obter as opiniões da comunidade SO sobre a melhor estratégia de versão de aplicativos.
Como você acompanha o número da versão do seu aplicativo? Você tem uma definição formal do que representa cada número / personagem dessa versão?
O que significam os diferentes números / strings na versão do aplicativo para o seu aplicativo?
Você usa qualquer sistema de atualização automatizado em suas aplicações (por exemplo, algo como Sparkle) e como ele tem sido bom para você?
Você tem um procedimento de atualização separado para testadores beta ou testadores de pré-lançamento do seu aplicativo?
marcado como duplicado pelo mosquito, MichaelT, Kilian Foth, GlenH7, Rein Henrichs 29 de abril 13 às 2:42.
Esta pergunta foi feita antes e já tem uma resposta. Se essas respostas não respondem totalmente a sua pergunta, faça uma nova pergunta.
migrou do stackoverflow 18 de maio às 11h48.
Esta questão veio do nosso site para programadores profissionais e entusiasta.
Como você acompanha o número da versão do seu aplicativo? Você tem uma definição formal do que representa cada número / personagem dessa versão?
O que significam os diferentes números / strings na versão do aplicativo para o seu aplicativo?
Eu uso o seguinte:
Major - A versão principal é um lançamento definitivo do produto. Aumentou quando há mudanças significativas na funcionalidade.
Menor - A versão menor é incrementada quando apenas foram adicionados novos recursos ou grandes correções de bugs.
Upgrade / Patch - Upgrade refere-se à substituição de um produto por uma versão mais recente do product. It é incrementado somente quando a atualização é fornecida na versão principal designada. A versão do programa começa com 0 e é incrementada somente quando o erro foi resolvido.
Build No - Build Number é incrementado quando a nova compilação é criada.
Você usa qualquer sistema de atualização automatizado em suas aplicações (por exemplo, algo como Sparkle) e como ele tem sido bom para você?
Nós usamos uma ferramenta de construção que automaticamente cria aplicativos à noite, que chamamos construção noturna e isso aumenta o número de compilação sempre que uma compilação é criada.
Você tem um procedimento de atualização separado para testadores beta ou testadores de pré-lançamento do seu aplicativo?
Não testadores testados durante a noite todas as manhãs que chamamos BAT (Build Aceceptance Test) e verificamos a construção noturna.
Permitam-me que note primeiro que parece não haver acordo sobre a "melhor" estratégia. Só posso compartilhar minha experiência em um projeto atual.
A versão do sistema é definida manualmente em uma propriedade de compilação. Acontece quando a equipe concorda em uma nova versão. Como versão de versão adicional, usamos o número de compilação que é gerado automaticamente pela construção do CI.
Seguimos vagamente o esquema de nomeação do Ubuntu YY. MM. version. patch_buildNumber, pois descobrimos que o controle de versão Major. Minor sujava as expectativas dos clientes;)
Não há atualizações automáticas, pois o aplicativo deve ser lançado por adminstrators.
Os lançamentos de teste são mais freqüentes do que as versões da GA, mas isso deve ser tudo.
Testei muitos sistemas de versões e agora estou muito feliz com este:
O Major é configurado manualmente e se refere a uma versão que inclui importantes melhorias. Menor também é configurado manualmente e se refere a uma versão de atualização / manutenção, incluindo melhorias menores e amp; correção A revisão é gerada automaticamente e se refere a uma revisão exata no repositório.
O último nos permite ser muito flexíveis com a versão. Podemos enviar múltiplas versões para vários clientes e ainda ser capazes de depurar & amp; conserte com facilidade obtendo a versão específica dos repos, então combine novamente com o tronco.
A construção, embalagem e amp; A publicação é totalmente automatizada. A única ação manual é quando movemos o último pacote para o servidor de produção por FTP. Queremos manter o controle sobre isso para garantir que não entregamos lixo na produção. Ele é um estágio preliminar em que os adotadores iniciais podem ler as notas da versão e depois decidir baixar e usar a versão. Os clientes que enfrentam erros específicos podem obter uma versão fixa muito rápido usando uma dessas versões.
Uso a versão semântica para as bibliotecas de código aberto e acho muito mais fácil trabalhar com outras bibliotecas que também o fazem. Ele fornece uma base comum para entender o que uma mudança de versão pode significar. A biblioteca ainda está em versão beta? É um lançamento apenas para correções de bugs? Haverá mudanças de API quebradas?
É basicamente uma codificação das melhores práticas de versão já utilizadas pela maioria dos projetos de código aberto.