Estratégia de versão de aplicativos

Estratégia de controle 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.

Estratégia de controle de versão
Obter através da App Store Leia esta publicação em nosso aplicativo!
Qual é uma boa estratégia de versão do aplicativo iOS ao usar o TestFlight para testes internos?
Eu tenho um aplicativo iOS que usa o controle de versão semântico para marcar compilações enviadas. Também estou usando o TestFlight da Apple para empurrar compilações internas para a equipe para testes / QA.
Empurrar uma compilação interna precisa carregar uma compilação para o iTunes Connect. Não há distinção entre uma compilação de teste e uma versão de lançamento para o iTunes Connect, e o iTunes Connect não permite substituir as versões carregadas anteriormente. Então, toda vez que eu quero empurrar uma nova compilação para teste interno, eu tenho que colidir o número da versão (bem, o número do patch (X. X. X).
Isso funciona bem, exceto para nossos usuários, parece que nossos números de versão saltam muito entre as atualizações. Por exemplo, se este é o nosso histórico de compilação:
. então os usuários estão apenas vendo os lançamentos em negrito, e nosso histórico de lançamento parece estranho:
Eu pensei que uma boa maneira de evitar isso é usar versões beta, como v1.1.0-beta para as compilações de teste, mas o iTunes Connect rejeita as cadeias de versões que não são X. X.X.
Existe uma maneira de continuar usando o TestFlight para testes internos / QA e evitar a aparência de um histórico de versões preenchido com lacunas aos usuários?
Eu uso um 4º número interno na versão de compilação, acredito que o iTunes ainda aceita isso. por exemplo. pode ser a versão 1.0.0, mas a compilação pode ser 1.0.0.87 indicando a 87ª compilação interna para testar. Você pode optar por diminuir o último número ao exibi-lo no aplicativo, mas as pessoas geralmente não se importam.
Descobriu isso fácil de entender e aceitar na maioria dos lugares.
O número de compilação em comparação com o número da versão não recebe crédito suficiente.

Estratégia de controle de versão
Obter através da App Store Leia esta publicação em nosso aplicativo!
Prática recomendada: Software Versioning [closed]
Existe alguma orientação ou melhor prática padrão sobre a versão de um software que você desenvolve em seu tempo livre para diversão, mas, no entanto, será usado por algumas pessoas? Eu acho que é necessário versão desse software para que você saiba sobre a versão um está falando (por exemplo, para corrigir bug, suporte e assim por diante).
Mas onde eu começo o controle de versão? 0.0.0? ou 0,0? E então, como eu incremento os números? Major release. minor change? e não deve se comprometer com um sistema de controle de versão ser outra versão? ou isso é apenas para versões que são usadas de forma produtiva?
fechado como primeiramente baseado em opinião por bummi, animuson & # 9830; 2 de agosto de 13 às 15h43.
Muitas boas perguntas geram algum grau de opinião com base na experiência de especialistas, mas as respostas a esta pergunta tendem a ser quase inteiramente baseadas em opiniões, ao invés de fatos, referências ou conhecimentos específicos. Se esta questão pode ser reformulada para ajustar as regras no centro de ajuda, edite a questão.
bloqueado pelo Flexo & # 9830; 21 de março às 21:32.
Esta questão existe porque tem significado histórico, mas não é considerada uma boa questão no tópico para este site, portanto, não use isso como evidência de que você pode fazer perguntas semelhantes aqui. Esta pergunta e suas respostas estão congeladas e não podem ser alteradas. Mais informações: centro de ajuda.
12 Respostas.
Você deve começar com a versão 1, a menos que você saiba que a primeira versão que você "liberar" está incompleta de alguma forma.
Quanto a como você incrementa as versões, depende de você, mas use a numeração importante, menor, como um guia.
Não é necessário ter todas as versões que você se comprometer com o controle de origem como outra versão - em breve você terá um número de versão muito grande. Você só precisa incrementar o número da versão (de alguma forma) quando você lançar uma nova versão para o mundo exterior.
Então, se você fizer um movimento de mudança importante da versão 1.0.0.0 para a versão 2.0.0.0 (você mudou de WinForms para WPF, por exemplo). Se você fizer uma mudança menor, mude de 1.0.0.0 para 1.1.0.0 (você adicionou suporte para arquivos png). Se você fizer uma alteração menor, vá de 1.0.0.0 para 1.0.1.0 (você corrigiu alguns bugs).
Se você realmente deseja obter informações detalhadas, use o número final como o número de compilação que aumentaria para cada check-in / commit (mas acho que está indo muito longe).
Eu usaria o tipo de versão x. y.z.
x - maior lançamento.
y - lançamento menor.
Número de compilação z.
Eu basicamente segui esse padrão:
Quando está pronto, eu ramo o código no repo de origem, marque 0.1.0 e crie o ramo 0.1.0, a cabeça / tronco se torna 0.2.0 instantâneo ou algo similar.
Eu adiciono novos recursos somente ao tronco, mas o backport corrige o ramo e, no tempo, eu liberto dele 0.1.1, 0.1.2,.
Eu declaro a versão 1.0.0 quando o produto é considerado recurso completo e não possui deficiências importantes.
a partir de então - todos podem decidir quando incrementar a versão principal.
Eu uso esta regra para minhas aplicações:
. y = número da função, 0-9. Aumente esse número se a alteração contiver novos recursos com ou sem correções de bugs. z = número do hotfix, 0-
. Aumente esse número se a alteração apenas contiver correções de bugs.
Para o novo aplicativo, o número da versão começa com 1.0.0. Se a nova versão contiver apenas correções de erros, aumente o número da correcção para que o número da versão seja 1.0.1. Se a nova versão contiver novos recursos com ou sem correções de bugs, aumente o número do recurso e redefina o número da correcção para zero, de modo que o número da versão será 1.1.0. Se o número do recurso atingir 9, aumentar o número da versão principal e redefinir o recurso e o número da correcção para zero (2.0.0, etc.)
Usamos a. b.c. d onde.
a - major (incrementado na entrega ao cliente) b - menor (incrementado na entrega ao cliente) c - revisão (incrementada em versões internas) d - build (incrementado pelo controle de cruzeiro)
Mais um exemplo para a abordagem A. B.C é o Eclipse Bundle Versioning. Os pacotes Eclipse preferem ter um quarto segmento:
No Eclipse, os números de versão são compostos por quatro (4) segmentos: 3 inteiros e uma seqüência de caracteres, respectivamente, chamado major. minor. service. qualifier. Cada segmento captura uma intenção diferente:
o segmento principal indica ruptura na API, o segmento menor indica mudanças "externamente visíveis", o segmento de serviço indica correções de bugs e a mudança de fluxo de desenvolvimento, o segmento qualificador indica uma compilação particular.
Há também o esquema de versão, por exemplo: AAAA. MM, YY. MM, AAAAMMDD.
É bastante informativo porque um primeiro aspecto dá uma impressão sobre a data de lançamento. Mas eu prefiro o esquema x. y.z, porque eu sempre quero saber o ponto exato de um produto em seu ciclo de vida (Major. minor. release)
A resposta básica é "Depende".
Qual é o seu objetivo no controle de versão? Muitas pessoas usam version. revision. build e apenas anunciam a versão. revisão ao mundo, pois é uma versão de lançamento em vez de uma versão do dev. Se você usa a versão de check-in, então você descobrirá rapidamente que seus números de versão se tornaram grandes.
Se você estiver planejando seu projeto, aumentaria a revisão para lançamentos com pequenas mudanças e aumentaria a versão para versões com grandes alterações, correções de erros ou funcionalidades / recursos. Se você estiver oferecendo versões de tipo de compilação beta ou noite, estenda o controle de versão para incluir a compilação e incrementar isso com cada versão.
Ainda assim, no final do dia, depende de você e isso tem sentido para você.
Como Mahesh diz: eu usaria o tipo de versão x. y.z.
x - lançamento principal y - versão menor z - número de compilação.
você pode querer adicionar um data-hora, talvez em vez de z.
Você incrementa a versão menor quando você tiver outra versão. O lançamento principal provavelmente ficará 0 ou 1, você altera isso quando você realmente faz grandes mudanças (muitas vezes, quando seu software está em um ponto em que não é compatível com versões anteriores, ou você mudou sua estrutura inteira)
Você sabe que você sempre pode verificar para ver o que os outros estão fazendo. O software de código aberto tende a permitir o acesso aos seus depósitos. Por exemplo, você pode apontar seu navegador SVN para svn. doctrine-project. org e dar uma olhada no sistema de versão usado por um projeto real.
Números de versão, tags, está tudo lá.
Seguimos a abordagem a. b.c como:
aumentar 'a' se houver algumas mudanças importantes ocorridas na aplicação. Como atualizamos o aplicativo 1.1 para 3.5.
increment 'b' se houver algumas alterações menores, como qualquer novo CR ou Enhancement for implementado.
increment 'c' se houver algumas correções de defeitos no código.
Eu começo o controle de versão no segmento mais baixo (não hotfix). Eu não limito esse segmento para 10. A menos que você esteja rastreando compilações, você só precisa decidir quando deseja aplicar um incremento. Se você tiver uma fase de QA, então pode ser onde você aplica um incremento ao segmento mais baixo e depois o próximo segmento quando ele passa QA e é lançado. Deixe o segmento mais alto para as principais mudanças de comportamento / UI.
Se você é como eu, você conseguirá um híbrido dos métodos para combinar o ritmo da progressão do seu software.
Eu acho que o padrão mais aceito a. b.c. ou a. b.c. d especialmente se você tiver QA / Compliance na mistura. Eu tive tanta onda de ser uma parte regular das versões que eu desisti da corrente principal.
Eu não rastreio construções, então eu gosto de usar o padrão a. b.c, a menos que haja uma atualização. Quando eu tenho que aplicar um hotfix, eu aplico o parâmetro d como uma data com o tempo. Eu adotei o parâmetro de tempo como d porque sempre há o potencial de vários em um dia em que as coisas realmente explodem na produção. Eu apenas aplico o segmento d (YYYYMMDDHHNN) quando estou divergindo para uma correção de produção.
Eu pessoalmente não seria contrário a um esquema de software de va. b revc onde c é YYYYMMDDHHMM ou AAAAMMDD.
Tudo o que disse. Se você puder simplesmente aproveitar uma ferramenta para configurar e executar com isso, você terá que evitar a dor de cabeça para fazer frente à face de opinião do controle de versão e você pode simplesmente dizer "usar a ferramenta". porque todos no processo de desenvolvimento geralmente são tão compatíveis.

O seu controle de versão da API é errado, razão pela qual eu decidi fazer 3 maneiras erradas diferentes.
No final, eu decidi que a maneira mais justa e equilibrada era irritar todos com igualdade. Claro que eu estou falando sobre o controle de versão da API e não desde o grande & # x201C; tabs versus spaces & # x201D; debate eu vi tantas crenças fortes em campos completamente diferentes.
Isso estava bem. Quando eu construí Eu fui escolhido? (HIBP) no final de novembro, pretendia ser um serviço simples e rápido que algumas pessoas usariam. Eu acho que é justo dizer que os dois primeiros pontos foram alcançados, mas não o último. Não foi & # x201C; alguns & # x201D ;, de fato, no final da primeira semana, foi mais do que o Google Analytics poderia lidar. O objetivo é que você sempre pode prever o futuro quando você escreve sua API e, em algum momento, você pode precisar mudar algo em que as pessoas já dependem.
Mas aqui, o problema & # x2013; Toda vez que você começa a falar sobre qualquer coisa a ver com APIs por HTTP, isso acontece:
Todo o caminho em que você se transforma há diferentes pontos de vista filosóficos em & # x201C; o caminho certo & # x201D; e muito retroceder e avançar no REST, o que é RESTful, o que não é e se importa. Deixe uma conversa sobre as mudanças da API, o impacto no controle de versão, por que há tantas idéias divergentes sobre como deve ser feito e, em última análise, por que nenhuma das palavras é tão importante como realmente conseguir coisas feitas.
Puxando mais dados de violação.
Tendo em mente que a mesma API é usada para o recurso de pesquisa no site e agora também por terceiros que criam tudo, desde aplicativos de smartphones até ferramentas de teste de penetração, a resposta acima funcionou bem no início, mas foi limitada. Por exemplo, essa resposta também não funciona bem:
Por quê? Porque & # x201C; BattlefieldHeroes & # x201D; é Pascal-encapsulado, o que é ótimo para combiná-lo com classes CSS codificadas (embora provavelmente não seja uma boa abordagem de longo prazo) e para ter um & # x201C; stable & # x201D; nome para se referir a (eu ganhei & # x2019; t mudá-lo, mesmo se houver uma segunda violação), mas não é adequado para exibição como título. Tudo isso sai do Azure Table Storage e depois entrei no SQL Azure para extrair dados relacionais que realmente descrevem a violação. Um dos atributos desse armazenamento relacional é o nome que você vê acima.
O que eu realmente queria fazer era algo mais parecido com isto:
Pegue? Para o ponto anterior sobre o nome da infração, esse ainda está lá no atributo de nome, mas agora temos um título também. Isto é o que você mostra às pessoas & # x2013; & # x201C; Battlefield Heroes & # x201D; & # x2013; Mas, mais importante ainda, se Gawker for repetidamente, eu posso nomear a violação de algo como Gawker2014 e o título pode ser algo amigável ao longo das linhas de & # x201C; Gawker (Syrian Electronic Army Attack) & # x201D ;. Ele segmenta o que é estável e previsível a partir do que não é e significa que as pessoas podem criar dependências, como imagens ou outros recursos no atributo de nome.
Os outros dados devem ser bastante claros: a data da violação, quando foi adicionada ao sistema, o número de contas, a descrição da violação (novamente, isso pode mudar se a verbiagem precisa ser modificada) e & # x201C; DataClasses & # x201D ;. Uma das coisas que muitas pessoas pediram foi uma descrição do que foi comprometido na violação, então agora há um monte de atributos que podem ser adicionados através de uma coleção sobre a violação em si. Eu já mostrando estes abaixo de cada violação na página dos sites Pwned (esta é outra razão pela qual agora posso ajustar algumas das descrições).
Esta é uma mudança radical. Embora o sentimento da API seja o mesmo & # x2013; forneça um nome de conta, receba uma lista de brechas & # x2013; não há mais um conjunto de caracteres de violação de nomes de violação. Se eu simplesmente substituísse a API antiga por essa, as coisas iriam quebrar. APIs. Devo. Evoluir.
O software evolui, as APIs devem ser controladas.
Deixe-se ficar claro sobre isso: o mundo continua. A API para o HIBP durou cerca de 2 meses, não porque estava mal concebida, mas porque o serviço tornou-se selvagem, inesperadamente bem sucedido. Eu gosto desse tipo de problema, e você também deveria.
Agora eu tinha uma escolha; Ou eu poderia me contentar com o que eu tinha e privar as pessoas de uma maneira melhor, eu poderia adicionar ao serviço existente de forma não rompente ou eu poderia criar uma nova versão (embora expondo a mesma entidade de uma maneira diferente) e construa da melhor maneira que eu sabia; sem bytes desnecessários, modelados corretamente (até que eu decida que uma nova versão é mais correta) e uma boa representação da entidade que eu finalmente tentarei entrar nos consumidores & # x2019; aplicativos.
Não há nada de errado em apresentar uma nova versão de uma API quando é a coisa mais sensível. Por todos os meios, faça o seu mais difícil para obtê-lo & # x201C; right & # x201D; desde o primeiro dia, mas faça isso com a expectativa de que & # x201C; right & # x201D; é um estado temporário. É por isso que precisamos ser capazes de versão.
Os vários campos de versão.
Certo, então, como é difícil esse negócio de versão? Quero dizer, deve ser um exercício simples, certo? O problema é que ele é muito filosófico, mas, em vez de ficar atolado, por enquanto, deixe-me esboçar as três escolas comuns de pensamento em termos de como elas são praticamente implementadas:
URL: Você simplesmente bateu a versão da API no URL, por exemplo: haveibeenpwned / api / v2 / breachedaccount / foo Cabeçalho de solicitação personalizado: Você usa o mesmo URL que antes, mas adicione um cabeçalho como o & # x201C; api-version: 2 & # x201D; Aceitar cabeçalho: você modifica o cabeçalho de aceitação para especificar a versão, por exemplo & # x201C; Aceitar: application / vnd. haveibeenpwned. v2 + json & # x201D;
Houve muitas, muitas coisas escritas sobre isso e eu vou ligar para elas no final da publicação, mas aqui a versão abreviada é:
Os URLs sugam porque devem representar a entidade: na verdade eu realmente concordo com isso na medida em que a entidade I & # x2019; m recuperando é uma conta quebrada, e não uma versão da conta violada. Semanticamente, não é realmente correto, mas sim, é fácil de usar! Os cabeçalhos de solicitação personalizados sugam porque ele não é realmente uma maneira semântica de descrever o recurso: a especificação HTTP nos dá um meio de solicitar a natureza que nós gostamos do recurso representado por meio do cabeçalho de aceitação, por que reproduzir esta? Aceite cabeçalhos sugam porque eles são mais difíceis de testar: eu não posso mais apenas dar a alguém um URL e dizer & # x201C; Aqui, clique neste & # x201D; antes eles precisam construir cuidadosamente a solicitação e configurar o cabeçalho de aceitação adequadamente .
Os vários argumentos para e contra cada abordagem tendem a passar de & # x201C; Este é o & # x2018; right & # x2019; maneira de fazê-lo, mas é menos prático & # x201D; através de & # x201C; Esta é a maneira mais fácil de criar algo consumível o que, portanto, o torna & # x2018; direito & # x2019; & # x201D ;. Há muita discussão sobre hipermídia, negociação de conteúdo, o que é & # x201C; REST & # x201D; e todas as outras questões. Infelizmente, isso muitas vezes se torna filosófico e perde a visão do objetivo real: construir um software que funcione e particularmente para uma API, tornando-o facilmente consumível.
É sobre ter um contrato estável, estúpido!
Mais importante do que todo o desencadeamento e delírio sobre fazê-lo dessa maneira ou dessa forma é dar às pessoas estabilidade. Se eles investem o seu código de escrita de esforço duro para consumir a sua API, então você melhorará muito, não vá e quebre-a mais na linha.
Honestamente, os debates sobre o que é & # x201C; RESTful & # x201D; versus o que não é como se o próprio termo ditar seu sucesso é apenas louco. Transforme essa discussão em & # x201C; Aqui estão as razões práticas pelas quais isso faz sentido e isso é o que pode acontecer se você não fizer isso e # x201D ;, e eu sou todos os ouvidos. O problema é que até mesmo as vozes da razão nas discussões barulhentas deixam dúvidas sobre o que realmente é a melhor abordagem e, portanto, eu alcancei um compromisso & # x2026;
Aqui estão 3 maneiras erradas de consumir a API HIBP que você pode escolher agora.
Ok, agora que nós estabelecemos claramente o que você faz é errado, eu gostaria de lhe dar a escolha de escolher entre qualquer uma das 3 maneiras erradas. Aguarde & # x2013; o que?! É assim: no entanto, implemento a API, será muito difícil de consumir, muito acadêmico, muito provável que falhe no proxy ou algo como algo. Ao invés de escolher 1 maneira errada, eu decidi você dar todas as 3 maneiras erradas e você pode escolher aquele que é o menos errado para você.
Wrong way 2 - cabeçalho de solicitação personalizado:
Inevitavelmente, alguém me dirá que fornecer 3 maneiras erradas é a coisa errada a fazer. Won & # x2019; t significa mais código kludge para manter? Não, simplesmente significa que a implementação da API da Web subjacente é decorada com dois atributos:
O primeiro é simplesmente uma restrição de roteamento que implementa RouteFactoryAttribute. Eu passo na rota e passa na versão que pode mapear para essa rota, então a implementação procura a presença de uma & # x201C; api-version & # x201D; cabeçalho ou um cabeçalho de aceitação correspondente a este padrão:
Se a versão especificada em qualquer uma dessas combina com a especificada na restrição de roteamento, então esse é o método que será invocado. Esta é uma adaptação simples desta amostra no CodePlex.
O segundo atributo que decora o método GetV2 acima vem com cortesia da Web API 2 e o recurso de roteamento de atributos. Claro que sempre poderíamos fazer o roteamento na API da Web, mas geralmente foi definido globalmente. O roteamento de atributos como esse traz a definição da rota para o contexto onde ela é aplicada e torna mais fácil ver qual ação do controlador vai ser chamada por qual rota. Isso também significa que as implementações para todas as 3 maneiras erradas de chamar a API se juntam em um local limpo.
Então, em suma, não, isso não cria muito kludge e é muito fácil de manter. Cada uma das 3 abordagens retornará exatamente o mesmo resultado e, o mais importante, eles permanecerão estáveis ​​e ganharão mudar em qualquer maneira de quebrar e, no final do dia, isso é o máximo coisa importante, independentemente da opção que você escolher. A implementação inteira agora também está claramente documentada na página API do site.
Mas e se você não especificar uma versão?
Você conhece o pouco onde eu disse que você pode quebrar o que já existe? Sim, então isso significa que se você fizer o que faz agora e # x2013; não especifique uma versão & # x2013; então você obtém o que você recebe agora. Em outras palavras, nenhum pedido para uma versão específica significa que você obteve a versão 1.
Estou bem com isso, independentemente de ter alcançado este ponto por padrão. Eu sei que algumas pessoas sempre gostam de retornar a versão mais recente se um número não for especificado, mas IMHO que quebra todo o contrato & # x201C; estável & # x201D; objetivo; O que você obtém da API hoje pode ser completamente diferente do que você obtém amanhã se eu a revisar. Isso sugaria e isso quebraria coisas.
Você tem 3 opções, mas minha preferência pessoal é & # x2026;
Tenho o luxo de controlar a API e o principal consumidor de ser o próprio site da HIBP. Dado que eu forneci 3 opções para consumir a API, qual eu uso eu?
Eu fui com o favorito filosófico que é especificá-lo através do cabeçalho de aceitação. Eu não acho que isso é correto e os outros estão errados, e acho que isso faz mais sentido por duas razões principais:
Eu concordo que o URL não deve ser alterado: se concordarmos que o URL representa o recurso, a menos que tenhamos tentado representar diferentes versões do próprio recurso, então não, eu não acho que o URL deve mudar. As brechas para foo são sempre as brechas para foo e eu não acho que apenas porque eu mudo os dados retornados para que a localização do foo mude. Eu concordo que aceitar cabeçalho descreva como você gosta dos dados: Esta é uma semântica da especificação HTTP e assim como a semântica dos verbos de solicitação faz muito sentido (ou seja, estamos recebendo ou colocando ou excluindo ou postando) Da mesma forma, a maneira como o cliente gostaria que o conteúdo fosse representado.
De modo algum isso significa que eu acho que os outros dois estão errados e, francamente, não há melhor maneira de compartilhar a API com alguém do que dizer & # x201C; Aqui, clique neste & # x201D ;, mas quando eu puder construa facilmente a solicitação e gerencie os cabeçalhos, I & # x2019; fui com esta rota.
Na verdade, penso nisso, também uso a versão na rota do domínio. Por quê? Apenas através do processo de escrever esta API, eu estava constantemente me comunicando com as pessoas sobre as formas de consultá-lo (mais sobre isso mais tarde) e os atributos que retorna. Sendo capaz de passar e dizer e # x201C; Ei, aqui é o que eu penso e # x201D; e eles simplesmente clicam nela e obtêm resultados inestimáveis. Este é o ponto que os proponentes da abordagem de versão de URL têm razão: você simplesmente não pode fazer isso quando você depende dos cabeçalhos.
Ah, e no caso de você voltar a verificar-me, no momento da escrita, eu ainda não enviei o site para v2 da API. Agora que os dados de violação são retirados na API quando ocorre uma pesquisa, significa que tenho o luxo de não carregar todas as violações na fonte na carga inicial (isso nunca mais será sustentável à medida que o conjunto de dados se expandir). Este salvará um monte de tráfego de saída e acelerará as coisas para as pessoas em termos de obter o site carregado, mas também significa apenas um pouco mais de trabalho no meu fim. Fique ligado.
No encerramento.
Claramente, eu fiquei um pouco embaixo da boca em relação a tudo o que está errado, mas, honestamente, quanto mais você lê sobre isso e quanto mais perguntas você faz, mais errado toda rota parece de uma forma ou de outra. Na verdade, eu sei muito bem que existem aspectos da minha implementação que serão referidos como & # x201C; wrong & # x201D; (Eu posso pensar em pelo menos um casal) e, naturalmente, estou me preparando para o ataque potencial de feedback para esse efeito. Entretanto, cada uma dessas opções funciona e, francamente, para todos os propósitos práticos, elas funcionam tão bem quanto entre si.
Se eu puder deixar outros considerando como versão suas APIs com um pensamento final: Ninguém usará sua API até que você a tenha construído. Pare de procrastinar. Nenhum destes são & # x201C; bad & # x201D; em qualquer sentido tangível, eles simplesmente são diferentes. Todos são facilmente consumíveis, todos retornam o mesmo resultado e nenhum deles provavelmente terá algum impacto real no sucesso do seu projeto.
Referências.
Sobrecarga de pilha: melhores práticas para o controle de versão da API? (ótima pergunta, ótimas respostas, fechadas como & # x201C; não construtivas & # x201D ;, eu assumi porque & # x201C; Bill the Lizard & # x201D; saiu no lado errado da cama naquela manhã) Lexical Scope blog: Como é REST APIs versão? (boa comparação de práticas de versão em todos os serviços), embora agora tenha dois anos de idade) CodePlex: exemplo de restrição de roteamento (vinculado na página da API da Web da Microsoft como um exemplo de APIs de versão adicionando um cabeçalho personalizado) CodeBetter: Versioning RESTful Serviços (muito pragmático e uma boa descrição das várias formas em que uma API pode mudar) O blog de Vinay Sahni & # x2019; Melhores Práticas para Projetar uma API RESTURA pragmática (ele está discutindo a versão de URL por causa de & # x201C Exploração do navegador & # x201D;) Pivotal Lans: versão de API (boa visão das opiniões conflitantes lá fora) Web Stack of Love: Versão da API Web ASP com tipos de mídia (bom passo a passo para a criação de um aplicativo para suportar o controle de versão por negociação de conteúdo)
Oi, Troy Hunt, escrevo este blog, crie cursos para a Pluralsight e sou Diretor Regional da Microsoft e MVP que viaja no mundo falando em eventos e treinando profissionais da tecnologia.
Oi, Troy Hunt, escrevo este blog, crie cursos para a Pluralsight e sou Diretor Regional da Microsoft e MVP que viaja no mundo falando em eventos e treinando profissionais da tecnologia.
Próximos eventos.
Costumo executar workshops particulares em torno destes, aqui estão os próximos eventos públicos em que irei:
Já não tem o Pluralsight? Que tal uma versão gratuita de 10 dias? Isso lhe dará acesso a milhares de cursos entre os quais são dezenas de meus, incluindo:
"The Cloud Never Goes Down", Azure SLAs e outras trivia de disponibilidade.
Veja como Bell foi pirateado - injeção SQL por sopro.
Inscreva-se agora!
Copyright 2017, Troy Hunt.
Este trabalho está licenciado sob uma licença internacional Creative Commons Attribution 4.0. Em outras palavras, compartilhe generosamente, mas forneça atribuição.
Aviso Legal.
As opiniões expressadas aqui são minhas e podem não refletir as pessoas com quem trabalho, meus companheiros, minha esposa, as crianças, etc. A menos que eu esteja citando alguém, eles são apenas meus próprios pontos de vista.
Publicado com o Ghost.
Este site funciona inteiramente no Ghost e é possível graças ao seu amável suporte. Leia mais sobre por que eu escolhi usar Ghost.