Estratégia de versão de sabão

Estratégia de versão de sabão
Obter através da App Store Leia esta publicação em nosso aplicativo!
Controle de API da Web Services.
Ofereço uma pequena API de Serviços Web para meus clientes, que planejo evoluir ao longo do tempo. Então eu preciso de algum tipo de versão, mas não consigo encontrar nenhuma informação sobre como você faz algo assim.
Existe uma melhor prática?
Como posso continuar adicionando novas funcionalidades sem quebrar a compatibilidade com os consumidores de serviços da Web?
O controle de versão é um tópico complexo, então primeiro você precisa definir seus objetivos de forma mais descritiva. Seria ótimo dizer que você possui uma interface que assegura que você nunca quebrará a compatibilidade, mas dependendo do que é a nova funcionalidade, talvez nem seja possível. Portanto, existem diferentes situações e trade-offs diferentes.
Se a sua intenção é apenas fornecer novas funcionalidades a novos consumidores, e todos os seus consumidores são consumidores diretos (sem intermediários, frameworks, etc.), então uma abordagem de ponto final discreto é a melhor escolha. Cada vez que você adiciona uma característica que arrisca uma ruptura, crie um novo ponto final, dê-lhe um novo número de versão e, em seguida, deixe os consumidores saberem para validar contra e mudar suas configurações. Esta estratégia é bastante tentada e verdadeira, mas tem as desvantagens de colocar o fardo sobre os consumidores para manterem-se atualizados. Além disso, se houver dependências entre serviços, ele pode se tornar uma tarefa rudimentar. O lado positivo é se o código quebrar não é (diretamente) sua culpa.
A outra estratégia principal é a interface extensível. Existem três variedades diferentes aqui que tenho conhecimento. Primeiro, é o tipo de interface que tenta tão bem descrever o domínio do serviço que todas as funções possíveis que você pode adicionar são de alguma forma possíveis, dada a interface existente. Se isso parecer difícil, é. Você pode chamar isso de interface perfeita. Tudo é completamente descrito, mas o domínio inteiro também é completamente descrito. O "perfeito" é realmente apenas em papel.
A segunda variedade é o tipo que parece uma interface normal, mas adiciona pontos de extensão genéricos. Em WSDLs, isso significa xs: qualquer, pares de nome-valor ou algo semelhante. Você pode chamar isso de interface básica extensível. Não é muito difícil de fazer, mas não é sem suas complicações. Os pontos de extensão podem tornar a interface mais difícil de trabalhar em certas ferramentas (xs: qualquer), ou perder explicitamente a sua capacidade de validar entradas e saídas (pares nome-valor). Também é muito fácil abusar desses pontos de extensão de uma forma que torna a versão 3 ou 4 muito difícil de usar.
A terceira variedade é o tipo que converte sua interface em um byte-stream. Você pode chamar estas interfaces Deus. Eles não estão sem suas justificativas, mas se você estiver usando um, você pode querer perguntar por que você está usando os serviços da Web. Talvez você devesse estar pensando em TCP / IP bruto, ou HTTP GET / POST básico. Mas talvez você esteja cansado da complexidade de WSDLs e XSDs e você quer começar do zero, mas você está vinculado a serviços da web por algum motivo de infraestrutura. Perceba, no entanto, que, uma vez que você inicia esse caminho, você precisará de uma maneira totalmente nova de descrever aos seus consumidores como usar / não usar seu serviço, e se você usar o XSD para isso ... bem, você está basicamente de volta onde você começou.
Sua melhor aposta é conhecer todas essas opções e abordar o design do seu serviço tentando pela primeira vez a "interface perfeita", desistindo e adicionando pontos genéricos de extensibilidade. Tentando projetar a interface perfeita, irá forçá-lo a aprender coisas que melhorarão o seu serviço, não apenas a sua interface, mas isso levará tempo e, se você não limitar esse tempo de alguma forma, isso levará uma eternidade.
Um pouquinho de uma verdadeira interface de deus, existe a interface do wrapper. Se você possui camadas de sistema, você deseja que sua interface esteja em camadas também. Quando você muda a camada B, você só quer mudar a camada B, nem todas as instâncias na camada C.
A estratégia mais comum que eu vi é a versão do WSDL, adicionando a identificação do controle de versão (normalmente aaaa / MM [/ dd]) ao namespace de objetos no wsdl, a saber:
Isso pode ser feito em um nível per-type (types / schema) ou em todo o nível WSDL - & lt; definitions & gt; em 1.1 ou & lt; descrição & gt; em 2.0.
Um pouco datado, mas esse link do IBM Developer Works fornece o raciocínio para essa abordagem e, especificamente, quando as versões precisam ser incrementadas:
Versões compatíveis com versões anteriores / não-rompentes:
Removendo ou renomeando operações Alterando parâmetros para um método Mudando um tipo complexo.
Eu geralmente adiciono a seqüência de versão ao URL do serviço da web, me dando "pontos de extremidade versionados". O código que implementa esses pontos finais pode ser compartilhado, se as diferenças são triviais e podem ser tratadas pelo mesmo código, ou o código pode ser clonado ou em algum lugar intermediário.
Os diferentes pontos de extremidade controlados também podem usar os esquemas XML versionados, se for isso que você precisa.
Uma das possibilidades é projetar todas as operações do serviço web para ter apenas um parâmetro de um tipo que herda de algum tipo abstrato que contenha o número da versão. Esta abordagem é implementada pela plataforma de serviços da Web eBay. Algo como o seguinte:
Além disso, se você trabalha em http, talvez seja necessário adicionar a versão como um parâmetro http GET para o URL do ponto final do serviço web, para que você possa detectar a versão solicitada facilmente servidor / serviço? Versão = 1.
Adicione o "número da versão da API" como parâmetro em todas as APIs, em seguida, implemente o padrão de estratégia no seu código de serviço da web, onde o número da versão determina a estratégia a ser usada.

Estratégia de versão de sabão
Obter através da App Store Leia esta publicação em nosso aplicativo!
Estratégias para atualização ou versão de serviços da Web?
Estou interessado em ouvir as melhores práticas sobre como as diferentes versões dos serviços da Web são tratadas.
Para esclarecer, se você tiver alguns métodos da Web expostos como um serviço da Web, então você deseja adicionar uma característica / funcionalidade e, assim, alterar a assinatura dessas chamadas de método, como você lida com isso de uma maneira que não quebra tudo dos seus clientes que atualmente chamam de serviço?
Você implanta o serviço em um URL diferente?
Você coloca uma versão no próprio nome do método (MyMethod, MyMethodv2 etc. - ugh ..)
Você passa uma versão como parte da chamada do método junto com uma lista de parâmetros?
Alguém sabe como o Google ou o Amazon lidam com esse cenário com sua extensa biblioteca de serviços da Web?
EDIT: Até agora, encontrei algumas informações boas neste artigo da Oracle. Também esta entrada de blog em alguns detalhes do Java foi útil. Ainda estou curioso para ver algumas das outras abordagens.
A maneira típica de versionar um serviço da Web é ter clientes especificando a versão desejada. Você pode permitir restrições simples, como "> 2.0", "& lt; 1.5", ou "= 1.1". Naturalmente, você deseja minimizar o número de versões suportadas para sua própria sanidade. Se um cliente não especificar uma versão, você assume o mais recente.
As técnicas para fornecer a versão variam. Alguns defendem o uso do URL, outros encorajam cabeçalhos, alguns podem incluí-lo como um parâmetro da chamada api. Quase nenhum mudaria o nome do método, no entanto. Isso é equivalente ao "pacote" ou "namespace" que controla o link do OSGi. Isso tornará a atualização muito difícil e impedirá as pessoas de atualizar mais do que quaisquer alterações ao serviço real.
Também depende da forma como você acessa seus serviços na web. Se você estiver usando o REST, manter o URL limpo e usando cabeçalhos faz mais sentido (e seria trivial cortá-lo como um parâmetro de consulta, se necessário). Se você estiver usando SOAP / XMLRPC / o que for, o RPC, então, colocá-lo no URL geralmente é bom.
Como o cliente especifica a versão geralmente é bastante fácil. O que é mais complicado é como você executa todas as versões simultaneamente. A maioria dos idiomas não tem uma maneira de carregar várias versões da mesma biblioteca / módulo / classe / função no mesmo ambiente de tempo de execução (seja uma VM, processo ou o que você tem). O link OSGi fornecido é a solução de Java para permitir isso.
Na prática, a OSGi será superada para a maioria das situações. Normalmente, é mais fácil enviar solicitações obsoletas para outro servidor ou processo.
A melhor maneira de "versão" de seus serviços, no entanto, é criar extensibilidade e flexibilidade para eles, de modo que permaneçam compatíveis e compatíveis. Isso não significa que todas as versões devem ser compatíveis entre si, mas as versões consecutivas devem ser compatíveis entre si.
Posso dizer-lhe que a solução de criar doAPIFunction, doAPIFunctionV2 e doAPIFunctionV3, etc, produziu apenas dores de cabeça no local em que trabalho. Adicione a isso a falta de nomes de funções claramente descritivos significa todo tipo de loucura.
Você quer nomes claros da função da API e, se uma api estiver mudando, o objetivo seria tentar fazê-lo de forma compatível com versões anteriores. Eu sugeriria o controle de versão de seus pontos de entrada para que cada ponto de entrada suporte uma API estável e doFunction no exemplo / api-1.0 / pode ser diferente do exemplo / api-2.0 se existisse uma boa razão para mudar a semântica.
Não tenho certeza se eu entendi sua pergunta corretamente. Mas meus 2 centavos. Se a assinatura do método muda como outro novo parâmetro, por que não pode ser feito opcional? Mas se um tipo de dados de parâmetro existente for alterado, não será aplicável.
Vote para isso se está errado. :)
Ele costumava ser mais simples quando você poderia ter o mesmo nome do método de serviço na web, e diferentes parâmetros, há anos. :)
Uma vez que você escreve um serviço na web, você está fazendo um contrato com os clientes que é isso que você apoiará.
Para métodos mais antigos, sugiro iniciar sessão para ver se eles estão sendo usados ​​e por quem, para ver se você pode fazê-los atualizar.
Além disso, é melhor você simplesmente escrever um novo método, então você pode ter vários nomes de funções similares que diferem por uma versão.
O problema com a passagem de um número de versão é que você deve garantir que os clientes sempre passem num número válido, o que, se você gerar os talões, funcionará, mas, se não o fizer, isso é muito frágil.
Colocar um número de versão no nome parece funcionar melhor para mim, pois torna óbvio o que é antigo e você pode usar o AOP para registrar mais facilmente versões antigas dos métodos de serviço na web.

Estratégia de versão de sabão
Thomas Erl é um autor de TI e fundador da Arcitura e comércio; Education Inc. Thomas é o autor de tecnologia do serviço mais vendido no mundo por mais de sete anos e é o editor de séries da Prentice Hall Service Technology Series de Thomas Erl (servicetechbooks). Com mais de 300.000 cópias impressas em todo o mundo, seus livros se tornaram best-sellers internacionais e foram formalmente aprovados por membros seniores das principais organizações de TI, como IBM, Microsoft, Oracle, Intel, Accenture, IEEE, HL7, MITRE, SAP, CISCO, HP, e muitos outros.
Vários de seus livros, incluindo Cloud Computing Design Patterns, Cloud Computing: Concepts, Technology & amp; Arquitetura, SOA Design Patterns, SOA Principles of Service Design e SOA Governance, foram criados em colaboração com a comunidade de TI e contribuíram para a definição de mecanismos de tecnologia da computação em nuvem, o modelo arquitetônico orientado para o serviço e a orientação do serviço como um paradigma distinto . Seu título mais recente, Arquitetura Orientada a Serviços: Análise & amp; Design para Serviços e Microservices, posiciona formalmente e introduz novos padrões para o modelo arquitetônico da Microservice como parte da SOA.
Como CEO da Arcitura & Trade; Education Inc. e em cooperação com SOA School, Cloud School e Big Data Science School, Thomas liderou o desenvolvimento de currículos para o SOA Certified Professional reconhecido internacionalmente (SOACP), Cloud Certified Professional (CCP) e Big Data Science Certified Professional (BDSCP ) programas de acreditação, que estabeleceram uma série de certificações de indústria formal, neutras do fornecedor, obtidas por milhares de profissionais de TI em todo o mundo.
Thomas é o membro fundador do SOA Manifesto Working Group e autor do Annotated SOA Manifesto (soa-manifesto). Durante 10 anos, ele foi o editor da The Service Technology Magazine, e ele supervisiona as iniciativas SOAPatterns, CloudPatterns e BigDataPatterns, dedicadas ao desenvolvimento contínuo de catálogos de padrões principais para arquitetura orientada a serviços, computação em nuvem e Big Data .
Thomas visitou mais de 20 países como palestrante e instrutor e participa regularmente de conferências internacionais. Mais de 100 artigos e entrevistas de Thomas foram publicados em numerosas publicações, incluindo The Wall Street Journal e CIO Magazine.
David Orchard é o ex-diretor técnico do BEA Systems CTO Office, com foco em padrões de serviços da Web. Ele é um membro eleito do Grupo de Arquitetura Técnica do W3C e é um editor nomeado da extensibilidade e versão de versão do W3C TAG; Arquitetura de serviços da Web, XML e comitês consultivos.
Ele é atualmente ou foi um co-editor da arquitetura de serviços da Web, cenários de uso de serviços da Web, WS-Coordination, WS-ReliableMessaging, WS-Addressing, WS-Eventing, WS-MetadataExchange, WS-Transfer, SOAP-Conversation, XML Link e XInclude especificações.
Ele escreveu vários artigos técnicos, é o co-autor do Web Service Contract Design & amp; Versão para SOA, e é um falante freqüente em várias tecnologias relacionadas à Internet.
James Pasley é um arquiteto com Workday e um membro de sua equipe de Integração sob demanda. James é especialista no cliente que enfrenta aspectos da arquitetura de integração do Workday, como os serviços públicos da Web do Workday. James é editor do site de desenvolvimento do Workday e também cria muito material para os cursos de treinamento relacionados à integração da Workday. James juntou-se à Workday através da aquisição do software Cape Clear.
James ingressou no Cape Clear Software em 2001 como desenvolvedor principal do Cape Studio. Em 2003, James foi nomeado Arquiteto Chefe da Cape Clear, onde supervisionou o desenvolvimento do Enterprise Service Bus (ESB) do Cape Clear. Em 2005, James tornou-se Diretor de Tecnologia do Cabo Clear Software. A Cape Clear foi reconhecida pela Gartner e pela Forrester como o Enterprise Service Bus líder, oferecendo confiabilidade, escalabilidade e desempenho comprovados de integração sob demanda para conectar qualquer conteúdo, serviços ou software através da internet usando tecnologias de serviços da Web.
Antes de ingressar no Cape Clear Software, James trabalhou para a Siemens Nixdorf, desenvolvendo soluções seguras de mensagens X.400 e infra-estrutura de chave pública (PKI) para uma variedade de produtos.
James possui um B. A. (Moderator) em Computer Science do Trinity College, Dublin e é co-autor do Web Service Contract Design & amp; Versão para SOA.
Fundamentos de versão do contrato de serviços da Web Parte II:
Identificadores de versão e estratégias de versão.
Resumo: Existem diferentes formas de contratos de serviços de versão com base em políticas, prioridades e requisitos. Este, o segundo artigo em uma série de duas partes do livro "Web Service Contract Design & Versioning for SOA", apresenta três estratégias de controle de versão comuns: rigorosas, flexíveis e soltas. Os prós e contras de cada abordagem são discutidos e classificados em relação ao rigor, impacto de governança e complexidade. O papel dos identificadores de versão também é explorado através de uma série de exemplos.
O seguinte artigo é um trecho do novo livro "Web Service Contract Design and Versioning for SOA" [REF-1] Copyright 2008 Prentice Hall / Pearson PTR e SOA Systems Inc. Observe que as referências dos capítulos foram intencionalmente deixadas no artigo, conforme requisitos de Prentice Hall.
Um dos padrões de design mais fundamentais relacionados ao design do contrato de serviços da Web é o padrão de identificação da versão. Ele essencialmente defende que os números de versão devem ser claramente expressos, não apenas no nível do contrato, mas até as versões dos esquemas que estão subjacentes às definições das mensagens.
O primeiro passo para estabelecer uma estratégia de controle de versão efetiva é decidir sobre um meio comum pelo qual as próprias versões são identificadas e representadas nos contratos de serviços da Web.
As versões quase sempre são comunicadas com os números de versão. O formato mais comum é um decimal, seguido por um período e depois outro decimal, como mostrado aqui:
Às vezes, você verá um período adicional + pares decimais que levam a números de versão mais detalhados como este:
O significado típico associado a esses números é a medida ou o significado da mudança. Incrementar o primeiro decimal geralmente indica uma grande mudança de versão (ou atualização) no software, enquanto que os decimais após o primeiro período geralmente representam vários níveis de mudanças de versão menores.
Do ponto de vista da compatibilidade, podemos associar significado adicional a esses números. Especificamente, a seguinte convenção surgiu no setor:
Espera-se que uma versão menor seja compatível com outras versões menores associadas a uma versão principal. Por exemplo, a versão 5.2 de um programa deve ser totalmente compatível com as versões 5.0 e 5.1. Uma versão principal geralmente é esperada para quebrar a compatibilidade com programas que pertencem a outras versões importantes. Isso significa que a versão 5.0 do programa não deverá ser compatível com a versão 4.0.
Esta convenção de indicação de compatibilidade através de números de versão maiores e menores é referida como a garantia de compatibilidade. Outra abordagem, conhecida como "quantidade de trabalho", usa números de versão para comunicar o esforço que ocorreu na mudança. Um aumento da versão menor indica um esforço modesto, e um aumento importante da versão representa previsivelmente muito trabalho.
Essas duas convenções podem ser combinadas e muitas vezes são. O resultado é freqüentemente que os números de versão continuam a comunicar a compatibilidade como explicado anteriormente, mas às vezes aumentam em vários dígitos, dependendo da quantidade de esforço que entrou em cada versão.
Existem várias opções de sintaxe disponíveis para expressar números de versão. Por exemplo, você pode ter notado que a declaração declaração que começa um documento XML pode conter um número que expressa a versão da especificação XML que está sendo usada:
Esse mesmo atributo de versão pode ser usado com o elemento xsd: schema da raiz, da seguinte maneira:
Você pode criar uma variação personalizada desse atributo atribuindo-a a qualquer elemento que você definir (caso em que não é necessário nomear o atributo "versão").
Uma abordagem personalizada alternativa é incorporar o número da versão em um espaço para nome, como mostrado aqui:
Observe que se tornou uma convenção comum para usar valores de data em namespaces ao controlar os esquemas XML, da seguinte maneira:
Neste caso, é a data da alteração que atua como o identificador da versão. Para manter a expressão das versões de definição XML Schema alinhadas com as versões de definição WSDL, usamos números de versão em vez de valores de data nos exemplos ao longo dos próximos capítulos. No entanto, quando se trabalha em um ambiente em que as definições do Esquema XML são de propriedade separada como parte de uma arquitetura de dados independente, não é incomum que os identificadores de versão de esquema sejam diferentes dos usados ​​pelas definições WSDL.
Independentemente da opção que você escolher, é importante considerar o padrão de Versão Canonical que dita que a expressão das informações de versão deve ser padronizada em todos os contratos de serviços dentro do limite de um inventário de serviços. Em ambientes maiores, isso exigirá frequentemente uma autoridade central que possa garantir a linearidade, a consistência e a qualidade da descrição das informações da versão. Esses tipos de convenções transportam a forma como a informação de término do serviço é expressa (conforme explorado no Capítulo 23).
Não existe uma abordagem de versão exclusiva para todos. Como o controle de versão representa uma fase relacionada à governança no ciclo de vida geral de um serviço, é uma prática sujeita às convenções, preferências e requisitos que são distintos para qualquer empresa.
Mesmo que não haja uma técnica de versão de fato para o WSDL, XML Schema e WS-Policy, que inclui contratos de serviços da Web, surgiu uma série de abordagens de controle de controle comuns e recomendadas, cada uma com seus próprios benefícios e compensações.
Neste capítulo, vamos selecionar as três estratégias conhecidas:
Estrita - Qualquer alteração compatível ou incompatível resulta em uma nova versão do contrato de serviço. Esta abordagem não suporta compatibilidade para trás ou para frente.
Flexível - Qualquer alteração incompatível resulta em uma nova versão do contrato de serviço e o contrato foi projetado para suportar a compatibilidade com versões anteriores, mas não é compatível.
Solto - Qualquer alteração incompatível resulta em uma nova versão do contrato de serviço e o contrato foi projetado para suportar a compatibilidade com versões anteriores e antecipa a compatibilidade.
Essas estratégias são explicadas individualmente nas próximas seções e referenciadas em todos os capítulos restantes.
Estratégia # 1: Estratégia Estrita (Nova Mudança, Novo Contrato)
A abordagem mais simples para a versão do contrato de serviço da Web é exigir que uma nova versão de um contrato seja emitida sempre que qualquer tipo de alteração for feita em qualquer parte do contrato.
Isso é comumente implementado alterando o valor de espaço de nome de destino de uma definição WSDL (e, possivelmente, a definição XML Schema) sempre que uma alteração compatível ou incompatível é feita com o WSDL, XML Schema ou WS-Policy relacionado ao contrato. Namespaces são usados ​​para a identificação de versão em vez de um atributo de versão, porque alterar o valor do namespace força automaticamente uma mudança em todos os programas de consumidor que precisam acessar a nova versão do esquema que define os tipos de mensagem.
Esta abordagem "super estrita" não é realmente prática, mas é mais segura e às vezes justificada quando há implicações legais para as modificações do contrato de serviços da Web, como quando os contratos são publicados para determinadas trocas de dados entre organizações. Uma vez que as alterações compatíveis e incompatíveis resultarão em uma nova versão do contrato, esta abordagem não suporta compatibilidade para trás ou para frente.
O benefício desta estratégia é que você tem controle total sobre a evolução do contrato de serviço, e porque a compatibilidade para trás e para frente é intencionalmente desconsiderada, você não precisa se preocupar com o impacto de qualquer mudança em particular (porque todas as mudanças efetivamente quebram o contrato).
Em contrapartida, ao forçar um novo espaço de nome no contrato com cada mudança, você está garantindo que todos os consumidores de serviços já existentes não serão mais compatíveis com qualquer nova versão do contrato. Os consumidores só poderão continuar a se comunicar com o serviço da Web enquanto o contrato antigo permanecerá disponível ao lado da nova versão ou até que os próprios consumidores sejam atualizados para se adequarem ao novo contrato.
Portanto, essa abordagem aumentará a carga de governança dos serviços individuais e exigirá estratégias cuidadosas de transição. Ter duas ou mais versões do mesmo serviço coexistir ao mesmo tempo pode se tornar um requisito comum para o qual a infraestrutura de inventário do serviço de suporte precisa ser preparada.
Estratégia # 2: A Estratégia Flexível (Compatibilidade para trás)
Uma abordagem comum usada para equilibrar considerações práticas com uma tentativa de minimizar o impacto das alterações nos contratos de serviços da Web é permitir mudanças compatíveis, sem forçar uma nova versão do contrato, sem tentar suportar compatibilidade.
Isso significa que qualquer alteração compatível com versões anteriores é considerada segura na medida em que acaba por estender ou aumentar um contrato estabelecido sem afetar nenhum dos consumidores existentes do serviço. Um exemplo comum disso é adicionar uma nova operação a uma definição WSDL ou adicionar uma declaração de elemento opcional à definição de esquema de uma mensagem.
Tal como acontece com a estratégia Strict, qualquer alteração que quebra o contrato existente resulta em uma nova versão do contrato, geralmente implementada ao alterar o valor do espaço para nome do destino da definição do WSDL e potencialmente também a definição do Esquema XML.
A principal vantagem para esta abordagem é que ele pode ser usado para acomodar uma variedade de mudanças, mantendo consistentemente a compatibilidade para trás do contrato. No entanto, quando as alterações compatíveis são feitas, essas alterações se tornam permanentes e não podem ser revertidas sem introduzir uma alteração incompatível. Portanto, é necessário um processo de governança durante o qual cada alteração proposta é avaliada para que os contratos não se tornem excessivamente inchados ou complicados. Esta é uma consideração especialmente importante para os serviços agnósticos que são fortemente reutilizados.
Estratégia # 3: A Estratégia Fraca (Compatibilidade para trás e para a frente)
Tal como acontece com as duas abordagens anteriores, esta estratégia exige que as alterações incompatíveis resultem em uma nova versão do contrato de serviço. A diferença aqui é a forma como os contratos de serviços foram projetados inicialmente.
Em vez de acomodar requisitos de troca de dados conhecidos, recursos especiais dos idiomas WSDL, XML Schema e WS-Policy são usados ​​para tornar partes do contrato intrinsecamente extensíveis para que permaneçam capazes de suportar uma ampla gama de requisitos de troca de dados futuros e desconhecidos.
O valor do atributo anyType fornecido pelo idioma WSDL 2.0 permite que uma mensagem consista em qualquer documento XML válido. Os curingas XML Schema podem ser usados ​​para permitir que um intervalo de dados desconhecidos seja passado nas definições de mensagens. Asserções de política ignoráveis ​​podem ser definidas para comunicar características de serviço que podem ser reconhecidas pelos consumidores futuros.
Esses e outros recursos relacionados à compatibilidade com versões anteriores são discutidos nos próximos capítulos.
O fato de que os curingas permitem que o conteúdo indefinido seja passado através de contratos de serviços da Web oferece uma oportunidade constante para expandir ainda mais o intervalo de conteúdo de elementos e dados de mensagens aceitáveis. Por outro lado, o uso de curingas resultará naturalmente em contratos de serviços vagos e excessivamente grosseiros que colocam a carga de validação na lógica do serviço subjacente.
Fornecido aqui é uma tabela que resume amplamente como as três estratégias se comparam com base em três características fundamentais.
Tabela 1 - Uma comparação geral das três estratégias de controle de versão.
As três características utilizadas nesta tabela para formar a base dessa comparação são as seguintes:
Strictness - A rigidez das opções de versão do contrato. A abordagem restrita é claramente a mais rígida em suas regras de versão, enquanto a estratégia Loose oferece a maior variedade de opções de controle de versão devido à dependência de curingas. Impacto de governança - A quantidade de carga de governança imposta por uma estratégia. As abordagens estritas e soltas aumentam o impacto da governança, mas por diferentes motivos. A Estratégia Estrita requer a emissão de novas versões de contratos, que afetam os consumidores e as infra-estruturas circundantes, enquanto a abordagem Loose introduz o conceito de conjuntos de mensagens desconhecidas que precisam ser acomodados separadamente através de programação personalizada. Complexidade - A complexidade geral do processo de versão. Devido ao uso de curingas e dados de mensagens desconhecidas, a estratégia Loose tem o maior potencial de complexidade, enquanto as regras diretas que formam a base da abordagem Strict tornam a opção mais simples.
Ao longo desta comparação, a estratégia Flexível oferece uma abordagem que representa um nível consistentemente médio de rigor, esforço de governança e complexidade geral.
Cada estratégia também determina como mudanças compatíveis, mudanças incompatíveis e identificadores de versão são usados ​​e aplicados em suporte às regras e convenções da estratégia. Os Capítulos 21, 22 e 23 exploram a aplicação dessas estratégias individualmente para definições de WSDL, definições de Esquema XML e definições de WS-Policy.

Quatro estratégias de versão da API REST.
Este artigo descreve quatro estratégias comuns de versão do REST API e explica como versão a API REST no xMatters.
Na xMatters, seguimos a especificação SemVer & # 8211; nós atualizamos a versão principal da API sempre que apresentamos mudanças de quebra. Internamente, atualizamos versões menores e patch sempre que adicionamos funcionalidades e atualizações compatíveis com versões anteriores. Quando lançamos uma nova versão principal da API REST do xMatters, os clientes podem optar por continuar usando uma versão principal existente ou migrar para a nova.
REST é, de longe, o estilo arquitetônico mais proeminente usado hoje para expor serviços a terceiros pela internet. Ele usa o padrão HTTP em vez de protocolos mais complexos, como SOAP ou RPC. A razão pela qual o REST foi tão bem sucedido é que imita como a web funciona:
Apátrida: não retém o contexto do cliente entre solicitações Cacheable: depende de regras de cache HTTP Orientação para cliente / servidor: separa preocupações entre clientes e servidores em camadas: aproveita um sistema em camadas e uma interface unificada.
Quatro estratégias comuns de controle de versão REST API.
Existem quatro maneiras comuns de versão de uma API REST.
1. Versões através do caminho URI.
Um caminho para a versão de uma API REST é incluir o número da versão no caminho do URL.
Esta estratégia é utilizada pela xMatters, bem como por outras empresas como Facebook, Twitter, Airbnb e outros.
Esta solução geralmente usa o roteamento URI para apontar para uma versão específica da API. Como as chaves de cache (nesta situação URIs) são alteradas pela versão, os clientes podem facilmente armazenar em cache os recursos. Quando uma nova versão da API REST é lançada, ela é percebida como uma nova entrada no cache.
A versão interna da API é a seguinte:
Versão principal: a versão usada na URI e denota alterações de quebra para a API. Internamente, uma nova versão importante implica criar uma nova API e o número da versão é usado para rotear para o host correto.
Versões menores e remessas: são transparentes para o cliente e são usadas internamente para atualizações compatíveis com versões anteriores. Eles geralmente são comunicados em logs de mudanças para informar os clientes sobre uma nova funcionalidade ou uma correção de bugs.
Esta solução tem uma pegada muito grande na base de código, pois introduzir mudanças de interrupção implica ramificar toda a API.
2. Versão através dos parâmetros da consulta.
Outra opção para a versão de uma API REST é incluir o número da versão como um parâmetro de consulta.
Esta é uma maneira direta de versão de uma API a partir do ponto de vista da implementação. Também é fácil predefinir a versão mais recente se um parâmetro de consulta não for especificado.
A principal desvantagem comparada à versão de URI é a dificuldade de roteamento. Os parâmetros de consulta são, de fato, mais difíceis de usar para rotear solicitações para a versão adequada da API.
3. Versões através de cabeçalhos personalizados.
As APIs REST também podem ser controladas através do fornecimento de cabeçalhos personalizados com o número de versão incluído como um atributo.
A principal diferença entre essa abordagem e as duas anteriores é que ela não destrói o URI com informações de versão.
4. Versões através da negociação de conteúdo.
Curl - H & # 8220; Aceitar: application / vnd. xm. device + json; versão = 1 e # 8221; exemplo / api / produtos.
A última estratégia que estamos abordando é o controle de versão através da negociação de conteúdo.
Esta abordagem nos permite a versão de uma única representação de recursos em vez de controlar a versão completa da API, o que nos dá um controle mais detalhado sobre o controle de versão. It also creates a smaller footprint in the code base as we don’t have to fork the entire application when creating a new version. Another advantage of this approach is that it doesn’t require implementing URI routing rules introduced by versioning through the URI path.
One of the drawbacks of this approach is that it is less accessible than URI-versioned APIs: Requiring HTTP headers with media types makes it more difficult to test and explore the API using a browser.
Content negotiation is a more granular approach because it versions resource representations instead of versioning the entire API, but it also comes with a high implementation cost for both clients and developers. More often than not, content negotiation needs to be implemented from scratch as there are few libraries that offer that out of the box. The other approaches are easier to implement and use but limit the developer’s ability to refactor due to the high cost of introducing breaking changes to the API contract.
Any thoughts or recommendations? Deixe um comentário abaixo!
Free White Paper: Learn About Standard+Case.
Learn more about taking a holistic approach to IT from Rob England at his blog, The IT Skeptic, and from his books, including Plus! The Standard+Case Approach. For more information, read Rob’s new white paper on turning undefined Case Management situations into new Standard Response Models, written for xMatters: Standard+Case: How IT Response Models Drive Modern Operations.
Do we need to make packging (folder) as per the major version ?
Another question is, How the version the schema if Api change require change in database tables. any link ?
One thing that is not very often documented is how to manage the code and all the versions that are supported by the API.
I’m interested to find a good pattern to manage our code and avoid version nightmare.
My implementation of 3rd approach for spring-webmvc:
Você também pode estar interessado em.
How We Hacked the Airbnb experience with AT&T, HP, and Intel.
New ServiceNow Integration Reduces Time to Resolve.
Moogsoft and xMatters Integration Takes Incident Management to a New Level.
Zombie Jobs Can’t Be Stopped By Email Broadcasts.
Need support?
Our dedicated community site is the best place to get help on all xMatters products. Our team of expert support staff and users inside our community can help you get the right answer.

Soap versioning strategy

Microservices Expo: Article.
Design Strategies for Web Services Versioning.
Adapting to the needs of the business.
Application versioning has always been a challenge for the developer community. With the introduction of Web services, this issue becomes even more difficult as developers are dealing with a more distributed set of components that aren't necessarily under their control.
A robust versioning strategy is needed to support multiple versions of Web services in development. This can allow for upgrades and improvements to be made to a Web service, while continuously supporting previously released versions. The right versioning strategy can maximize code reuse and provide a more manageable approach to the naming, deployment, and maintenance of your Web services.
The issue of versioning is a complicated one, and this article does not attempt to answer every question surrounding the versioning of XML and Web services. However, there are some key approaches and design practices that have been helpful in our development that we will share with you here. The approach we will take is to start at the component level (XML Schemas) and work up to higher service-level abstractions, including facades and service-oriented (SOA)–based architectures. Along the way, we hope to impart some important best practices that can be applied to incorporate versioning techniques at various levels of the design.
Let's begin by looking at the importance of XML Schemas.
The Importance of XML Schemas in Versioning.
Versioning for Web services should first consider how the XML Schemas being used are versioned. A number of approaches can be taken to version XML Schemas, including using a schema version attribute, changing the physical location of the schema, and leveraging XML Namespaces.
XML Namespaces provide a scoping mechanism for XML, where elements defined in that namespace can be uniquely identified. Namespaces are typically used to reduce name collisions between schemas, but they can also be used as a version control mechanism. Here's a simple example showing how Namespaces can be used for versioning:
A Web service referencing a versioned schema would be required to have knowledge of the version because it is built intothe targetNamespace. The benefit of this approach is that once the targetNamespace is updated, any clients that reference it are required to do something. This automatically enforces a level of version control, requiring some action on the client's part.
The downside of this approach is that any incremental change would require the client to also change. Clearly, a noncompatible change such as removing a WSDL operation being used by the client requires client modification. But, a change such as adding an optional attribute to the schema would still be compatible with the existing code. One key question that must be addressed in your design is: What changes should constitute a new Web services version? If you take the approach that any change results in a new Namespace, this will place a great burden on the developers using the schemas.
One proposed hybrid solution is to use a combination of Namespace and version ids. The targetNamespace would only be updated for non-compatible changes. For any incremental, compatible change, the version ID attribute could be used to identify the new revision. The following approach can significantly reduce the amount of maintenance required by the developer when new versions of a Web service are released.
Version compatibility can be a very difficult thing to determine. Without any robust development tools available for this, it is the responsibility of the development team to determine whether a new release maintains compatibility. In this section, we've presented a number of approaches to versioning XML Schemas. If you're considering versioning at this level of your architecture, we would recommend use of XML Namespaces in a limited capacity to indicate major version upgrades to the XML But, it is a good practice to fully test your services to verify version compatibility.
Naming Conventions for Versioning.
Having a name for each release of a Web service is essential for simplifying the management of the releases. The naming strategy should facilitate recognition of multiple versions of a Web service, including both existing and new interfaces. Different strategies can be implemented here, including using a sequential naming strategy or date stamps.
When you are sequentially naming your version you can use a convention of "vMajor#.Minor#/SERVICE_NAME, where Major# is the major version release and Minor# is the minor number release. A major release would most likely require a change in the client code to use the new version, while a minor release would attempt to maintain backward compatability with the client. A minor version could constitute a modification to a Web service that would impact the internal system only.
The standard method name for a Web service has "_v#_#" appended to the end of its name. Thus, for the getProductCatalog service we might define the operation as "getProductCatalog_v1_1". Or, if you are applying this to XML namespaces, it might look like:
Another way of naming versions is to use date stamps as part of the namespace. The date helps to determine the sequencing of the version. This naming convention does not show a major or minor release. Here's how this might look in our definition of the schema:
The important thing to remember is that there isn't one best solution in how you name the versions. Your approach will depend on the deployment strategy you use and the specific requirements your clients might have to distinguish versions and maintain compatibility.
It should also be apparent that these techniques can become very unmanageable if you have to apply them to every component in your design.
To address this, let's turn to a few important design practices for building more coarse-grained services with design patterns and service-oriented architectures.
Using Web Services Facades.
As organizations build, deploy, and orchestrate Web services, it becomes apparent that a higher level of versioning and management is required. You must begin thinking about services from a business level, rather than from the technical interfaces being exposed. However, many organizations investigating Web services are still looking at them as extensions to object-oriented paradigms. They make the mistake of taking their existing objects and exposing them directly with a Web services interface. This will most likely deliver Web services that are fine grained and difficult to use. It can also make it difficult to incorporate a consistent approach to Web services versioning.
Instead, think from the perspective of the WSDL first, and map to a back-end implementation later. This approach provides a more loosely coupled architecture, minimizing dependencies on specific implementations. You should also look to design patterns, such as the Web Services Facade, to assist in the creation of coarse-grained components. This pattern takes the complexity out of the interfaces being exposed. Rather than having multiple interface points to a collection of services, composite Web services can be designed with simpler, well-understood business interfaces.
As Figure 1 illustrates, the facade can be used to simplify the steps required to place a Change Order request. While this picture shows the facade being used from the perspective of the provider, a consumer of could also design facades to simplify access to services.
The use of this pattern can offer a number of benefits, including minimizing the level of coupling between consumer and service, creating a control point for manageability, and improving overall performance by reducing the number of network calls. The facade pattern can also provide a framework for managing the inherent complexity of supporting multiple Web services versions simultaneously.
One implementation of this pattern, shown in Figure 2, creates levels of abstraction by separating the code into three distinct tiers of classes: request handler classes, facade business flow classes, and business object classes.
The managing class, the session facade class, is responsible for chaining the smaller business object classes together. Each business object class contains a subunit of processing logic, and chaining of all these business object classes provides the core business logic. Each session facade class by itself contains no processing logic, but by concatenating business objects together it implements the desired business logic.
This architecture decouples processes from each other, allowing reuse of components. It also helps in managing the complexity of Web services as business requirements change in different versions of the service. Processes leveraged to execute business requirements are abstracted into individual pieces of software code that one managing class chains together to execute in sequence. By chaining these pieces of code together, required business processes are implemented to adhere to a specific business process flow. Thus, by building multiple managing classes, different business flows can be implemented and maintained simultaneously.
Importance of Service-Oriented Architectures.
The design of coarse-grained services is an important aspect of a versioning strategy, simplifying the client interfaces and maximizing reuse. Designing facades at the implementation level can help, but it still requires a significant change to the underlying infrastructure at various levels that someone has to deal with. What's truly needed is an SOA-based platform that can assist in the management of the entire life cycle of Web services.
An SOA-based approach offers software components as a collection of distributed business services. A business service plays the role of a single entity that represents a business application, and may include multiple IT resources, platforms, and components. The model, simplified in Figure 3, separates the roles of consumer, provider, and registry. A provider registers available services in a registry that the consumer can later discover and invoke. Consumers aren't directly aware of a specific service endpoint or the implementation details. The SOA provides a greater degree of separation between the provider and consumer, and as changes are made to a service, the SOA can help minimize the impact on the consumer.
An SOA typically requires some type of framework or platform that can act as an intermediary between providers and consumers. Without this intermediary in place, consumers would have to build a more tightly coupled integration with a service endpoint. This intermediary could be implemented as a proxy, a gateway, or a broker, handling issues such as security, routing, SLA management, and life-cycle management.
The life-cycle management features offered by the platform are key to our discussion of versioning. Some Web services and SOA management platforms on the market today offer support for life-cycle management. This might include: The ability to handle multiple versions of a service at the same time Deprecating or retiring services in a graceful manner Routing requests to the appropriate service endpoint based on a request Transforming requests and responses to maintain backward compatibility (e. g., using XSLT) Automated deployment of new versions without requiring system shutdown Managing dependencies that exist between different Web services Life-cycle management is also much more than just managing the deployment of Web services. From the perspective of a business service, life-cycle management might include many platforms, application servers, and database instances. To truly manage this level of a service, you must consider how all dependent application components and infrastructure elements are deployed and managed.
Let's look at an example showing a common versioning problem. In Figure 4, a provider has offered an initial version of a Web service, V1.0. The platform would automatically route requests for this service to an appropriate service endpoint. Routing could be determined based on information placed in a UDDI registry, or the underlying management model could manage this (e. g., through WSDM interfaces).
At some point, a second version of the service is deployed that maintains backward compatibility. Within the SOA, the new service is identified as supporting both the original business service and the new business service. Requests made for the original business service could be brokered to either service endpoint. Consumers wishing to access the new functionality would have to make the appropriate programmatic changes.
This approach to versioning allows an IT organization to better adapt to changes required by the business. Multiple versions of a service can be maintained simultaneously without impact to the consumer. Old versions can be retired gracefully, and consumers can upgrade on their own time, rather than being forced to when new versions are released.
Even with a solid design and robust architecture for versioning, there is still a human factor that must be considered in this process. Understanding the versioning life cycle will help you to implement new versions and deprecate the older versions effectively. The first step in this process is to put a solid plan together describing the life cycle of Web services being supported. This plan might include the following steps:
1. Determine how often versions are to be released . When considering frequency, you should consider how many versions of the Web service you want to support in parallel.
2. Understand the timeframe within which you expect consumers to move to a new version of a service . The Web services management platform may be able to provide guidance on service usage to determine the appropriate time to phase out older versions.
3. Consider releasing a pilot or an early release of a new version . Give consumers an opportunity to test compatibility and determine potential code impacts.
4. Approach Web services versioning the same way software packages might be released . Changes to your service, either as a result of bug fixes, partner requests, or specification upgrades, should follow a specific release cycle.
5. Clearly communicate your Web services versioning strategy to users of your Web service .
Once the versioning strategy is laid out for each release you should then consider the following steps:
1. After making the appropriate changes to your services, do unit and functional testing of the service.
2. Deploy the new service through appropriate schema, WSDL, and service changes. This step might include registration to a UDDI registry or the Web services platform.
3. Notify the consumers of your new service and pilot the new versions with one of your consumers.
4. Run the new and old versions in parallel for the timeframe you have allocated in your versioning plan.
5. Notify the consumers of your service of the date you expect to deprecate old versions.
6. Remove old versions from WSDL descriptions and UDDI registries to prevent new consumers from discovering and using the older versions.
7. Remove functionality of the old service, and add in appropriate functionality so existing consumers are properly notified (e. g., through a SOAP fault) that the old version is no longer supported.
One approach to deployment is shown in Figure 5. The calendar is shown in quarters of a company's financial calendar. The new version can be introduced at the beginning of a quarter (e. g., Q1 of 2003). It is valid for four quarters and then is sunset at the beginning of Q1 of 2004. In this case, the consumer of the service could be given six months to convert to the new version. You can also have minor versions released in between the major versions. These minor releases can then be folded into the Web service version 2.0 when it is released.
This article has presented a number of considerations when versioning Web services. Whether it's developing a versioning approach for schemas or building a full-scale versioning system using an SOA approach, there are a couple of key points that we would like to leave you with.
First, we hope it's obvious that versioning can become a nightmare as you deploy more and more versions of your service, especially if the service is being offered to different consumers. The goal of your design should be to build reusable components that can be leveraged and reused across the versions being managed. In the long run, this will reduce maintenance and deployment costs.
Second, don't underestimate the impact these changes might have on the consumer. While the design you introduce might reduce your development costs, you must also consider how these changes impact the end consumer. Service compatibility is key to this, and if new services maintain backward compatibility, consumers wishing to use the existing functionality shouldn't be required to change. The architecture should provide an easy migration and upgrade path for them.
Third, you want to strive to isolate the technical implementation and provide a clear separation between the consumer and provider. This might be implemented using design patterns such as the Facade, or it could require an SOA-based approach. Either way, the notion of coarse-grained business services offers a more loosely coupled architecture where consumers and providers can change without impacting the other party.
The last piece of advice we could offer is to not attempt to build the entire versioning infrastructure yourself. If you look at the requirements for manageability, they include a wide range of features such as routing, transformation, versioning, and security. Leveraging a vendor offering, especially one that provides a service-oriented approach IT management, can go a long way toward offering an architecture that can truly adapt to the changing needs of the business.
Published April 5, 2004 – Reads 53,770.
Direitos autorais e cópia; 2004 SYS-CON Media, Inc. — Todos os direitos reservados.
Histórias sindicadas e feeds de blog, todos os direitos reservados pelo autor.
More Stories By Chris Peltz.
Chris Peltz is a senior architect within HP's.
Developer Resources Organization (devresource. hp), providing technical and architectural consulting to enterprise customers in the areas of J2EE, Web services, and.
More Stories By Anjali Anagol-Subbarao.
Anjali Anagol-Subbarao works in HP's IT organization as an IT architect. She has 12 years of IT experience, the last five in Web services. Her book on J2EE Web services on BEA WebLogic was published in October 2004.
Clique neste link para ver como XML.
ADICIONE ESTA ALIMENTAÇÃO PARA O SEU LETRO DE NOTÍCIAS ONLINE.
Cloud Expo.
Toda a Cloud está na Cloud Expo!
Containers - Microservices - WebRTC - DevOps.
Junte-se ao Centro Javits em Nova York, NY, 6-8 de junho.
• Dados importantes | Analítica.
• Internet das Coisas.
Registrar agora!
Salve em seu "Passe de Ouro"! Ligue para 201.802.3020.
Ou clique aqui para registrar.
Envie sua proposta de fala para a próxima Cloud Expo em Nova York.
Ligue para 201.802.3021.
eventos (em) sys-con.
carmen (at) sys-con.
Todos os direitos reservados. Todas as marcas são marcas registradas da Ulitzer, Inc.
É proibida a reprodução total ou parcial de qualquer forma ou meio sem autorização expressa por escrito da Ulitzer, Inc.