Como a mudança para microsserviços cria um problema de tempo de execução?

O seguinte comentarista escreve :

Os microsserviços mudam sua disfunção organizacional de um problema de tempo de compilação para um problema de tempo de execução.

Este comentarista expande a questão dizendo:

Recurso não bug. Problema no tempo de execução => questões de produtos => feedback mais forte e rápido sobre a disfunção para os responsáveis

Agora eu entendo isso com microsserviços :

• potencialmente aumentar a latência do throughput - que é uma preocupação de produção e tempo de execução.
• aumente o número de "interfaces de rede" no seu código, onde pode haver erros potenciais de tempo de execução da análise.
• potencialmente pode fazer implantações azul esverdeado. Esses podem ser mantidos por incompatibilidades de interface (consulte interfaces de rede). Mas se as implantações azul esverdeado funcionarem, será mais uma preocupação em tempo de execução.

Minha pergunta é: O que significa mudar para microsserviços cria um problema de tempo de execução?

Eu tenho um problema. Vamos usar microsserviços! Agora eu tenho 13 problemas distribuídos.

Dividir seu sistema em componentes encapsulados, coesos e dissociados é uma boa idéia. Ele permite que você lide com diferentes problemas separadamente. Mas você pode fazer isso perfeitamente bem em uma implantação monolítica (consulte Fowler: Microservice Premium ). Afinal, é isso que a OOP ensina há muitas décadas! Se você decidir transformar seus componentes em microsserviços, não terá nenhuma vantagem arquitetural. Você ganha alguma flexibilidade em relação à escolha de tecnologia e, possivelmente (mas não necessariamente!), Alguma escalabilidade. Mas você tem uma certa dor de cabeça decorrente da (a) natureza distribuída do sistema e (b) da comunicação entre os componentes. Escolher microsserviços significa que você tem outros problemas tão urgentes que deseja usar os microsserviços, apesar desses problemas.

Se você não conseguir projetar um monólito que esteja claramente dividido em componentes, também não poderá projetar um sistema de microsserviço. Em uma base de código monolítica, a dor será bastante óbvia. Idealmente, o código simplesmente não será compilado se estiver terrivelmente quebrado. Mas com microsserviços, cada serviço pode ser desenvolvido separadamente, possivelmente até em idiomas diferentes. Quaisquer problemas na interação dos componentes não serão evidentes até você integrar seus componentes e, nesse ponto, já é tarde demais para corrigir a arquitetura geral.

A fonte número 1 de erros é a incompatibilidade de interface. Pode haver erros flagrantes, como um parâmetro ausente, ou exemplos mais sutis, como esquecer de verificar um código de erro ou esquecer de verificar uma pré-condição antes de chamar um método. A digitação estática detecta esses problemas o mais cedo possível: no seu IDE e no compilador, antes que o código seja executado. Os sistemas dinâmicos não têm esse luxo. Ele não explodirá até que esse código com defeito seja executado.

As implicações para os microsserviços são aterradoras. Os microsserviços são inerentemente dinâmicos. A menos que você mude para um idioma formal de descrição de serviço, não poderá verificar nenhum tipo de correção do uso da interface. você tem que testar, testar, testar! Mas os testes são caros e geralmente não exaustivos, o que deixa a possibilidade de que ainda possam existir problemas na produção. Quando esse problema se tornará aparente? Somente quando esse caminho defeituoso é percorrido, em tempo de execução, na produção. A noção de que questões de produtos levariam a um feedback mais rápido éhilariamente perigosamente errado, a menos que você se divirta com a possibilidade de perda de dados.

O primeiro tweet foi meu, então eu vou expandir:

Suponha que você tenha 100 desenvolvedores trabalhando em um aplicativo monolítico. São pessoas demais para se comunicar efetivamente entre si; portanto, a empresa precisa trabalhar duro para dividi-las em equipes menores e criar bons padrões de comunicação entre elas. Quando a organização é "disfuncional", as equipes provavelmente não estão conversando entre si, não estão alinhadas com um objetivo maior, discordam de prioridades etc. - como resultado, leva uma eternidade para enviar algo. É um "problema de tempo de compilação" no sentido de que a disfunção é óbvia antes do software ser produzido. O projeto provavelmente é uma marcha da morte ou nunca será lançado ("compilar").

Eu acho que muitas pessoas são atraídas por microsserviços e estão se mudando para eles, não por causa dos benefícios técnicos / arquitetônicos inerentes, mas porque lhes permite ignorar a disfunção organizacional. Em vez de tentar alinhar 100 desenvolvedores, eles esperam ter pequenas equipes trabalhando em silos, cada uma focada em seu próprio pequeno micro serviço. Se você está em uma organização tão disfuncional, isso é muito atraente: oferece uma permissão muito maior para evitar pessoas de quem você não gosta, para não se comunicar.

Infelizmente, isso se torna um "problema de tempo de execução" porque, uma vez que o software está em produção, uma boa comunicação se torna tão importante. Os problemas com a organização - as equipes e como eles estão alinhados e se comunicam - se manifestam no "tempo de execução".

O objetivo do meu tweet era: se o que você tem é um problema de pessoas , uma nova arquitetura não vai ajudar. Isso apenas atrasará os efeitos do problema. Penso que a atratividade de microsserviços para muitas pessoas é a esperança de que magicamente resolva esses problemas.

Minha pergunta é: O que significa mudar para microsserviços cria um problema de tempo de execução?

Não é isso que esses tweets estão dizendo! Eles não dizem nada sobre mudar para microsserviços , nem dizem sobre criar problemas. Eles só dizem algo sobre a mudança de problemas .

E eles colocam uma restrição contextual em suas afirmações, a saber, que sua organização é disfuncional.

Então, o que o primeiro tweet está basicamente dizendo é duas coisas:

• "se sua organização não puder projetar sistemas complexos agora sem microsserviços, ela não poderá magicamente projetar sistemas complexos com microsserviços" e
• "os problemas causados ​​por essa incapacidade que agora aparecem durante o tempo de compilação, ou seja, durante o desenvolvimento aparecerão durante o tempo de execução, ou seja, na produção" (tecnicamente, eles também podem aparecer durante o teste, mas lembre-se, a cotação se restringe organizações disfuncionais, que provavelmente possuem um regime de teste abaixo do padrão)

O segundo tweet diz que o fato de os problemas se manifestarem apenas na produção, ou seja, onde os clientes os veem, é um recurso, não um bug, porque quando os clientes reclamam, isso tende a ser ouvido em lugares diferentes do que quando uma compilação é interrompida, a saber em lugares capazes de fazer algo sobre a disfunção organizacional (por exemplo, gerenciamento de alto nível). Como a disfunção organizacional geralmente é uma falha no gerenciamento de alto nível, isso significa que os clientes insatisfeitos refletem mal sobre aqueles que são responsáveis ​​por essa insatisfação, enquanto a baixa qualidade do código causada por falhas no gerenciamento de nível superior geralmente reflete apenas sobre os desenvolvedores, que são , no entanto, não tem culpa e é incapaz de fazer algo a respeito.

Portanto, o primeiro tweet diz que os microsserviços movem os problemas causados ​​pelo mau gerenciamento do tempo de compilação, onde apenas os desenvolvedores os veem, para o tempo de execução, onde os clientes os veem. O segundo tweet diz que é uma coisa boa, porque então, os problemas ferem aqueles que são responsáveis ​​por eles.

Ele cria um problema de tempo de execução em oposição a um problema de tempo de compilação .

Um aplicativo monolítico é difícil e caro de compilar. Mas uma vez compilado, você pode ter certeza razoável de que não existem incompatibilidades extremamente estúpidas entre os componentes, porque o sistema de tipos pode detectá-los. O mesmo erro em um sistema de microsservivos pode não aparecer até que dois componentes específicos realmente interajam de uma maneira específica.

Tanto em sistemas monolíticos quanto em microsserviços, é necessário definir interfaces entre os subsistemas. As interfaces devem ser bem projetadas, bem documentadas e o mais estável possível. É o mesmo que em OOP.

Se sua organização não conseguir fazer isso, os microsserviços também não resolverão o problema. Nos microsserviços, você possui interfaces públicas da Web. Então você precisa gastar mais esforço no design de interface.

Se a interface não for projetada corretamente, você terá dois tipos de problemas de tempo de execução:

1. Se a interface não for usada corretamente, você receberá um erro no tempo de execução, não no tempo de compilação.
2. A chamada de uma interface da Web é bastante lenta, para que você possa ter problemas de desempenho.

Acho que produzir problemas de tempo de execução não é o caminho certo para comunicar problemas organizacionais àqueles que são responsáveis.