Microservices

Por mais de uma década, o Spring Boot reinou supremo como o padrão de fato para a criação de aplicativos Java corporativos. Seu rico ecossistema, paradigma de convenção sobre configuração, mecanismo robusto de injeção de dependência e vasto suporte da comunidade fizeram do Java a base dos sistemas back-end em todo o mundo.

Por quase três décadas, Java tem sido a força dominante no desenvolvimento de software empresarial. Seu rico ecossistema, base robusta orientada a objetos, independência de plataforma por meio da Java Virtual Machine (JVM) e estruturas testadas em batalha como Spring Boot tornaram-no o rei indiscutível da infraestrutura de back-end.

Em aplicativos monolíticos tradicionais, manter a consistência dos dados em diversas entidades é simples. Os mecanismos de banco de dados relacional fornecem garantias ACID (Atomicidade, Consistência, Isolamento, Durabilidade) agrupadas em transações SQL locais. Se uma colocação de pedido, dedução de pagamento ou reserva de estoque falhar no meio, chamar ROLLBACK reverte todas as modificações do banco de dados instantaneamente.

Na arquitetura moderna de microserviços orientada a eventos (Event-Driven Architecture), os serviços emitem eventos como OrderCreated ou PaymentProcessed para comunicar alterações de estado de forma desacoplada. No entanto, publicar eventos de forma totalmente confiável apresenta um desafio crítico: Como garantir que a atualização da base de dados e a publicação do evento ocorram juntas com sucesso ou falhem juntas?

Numa arquitetura de microsserviços, os serviços formam uma rede de chamadas de rede distribuídas. Embora isso permita que as equipes criem e dimensionem serviços de forma independente, também significa que a confiabilidade geral do seu sistema é tão forte quanto o seu elo mais fraco. Se um serviço crítico falhar ou parar de responder, poderá desencadear uma falha em cascata que interromperá todo o aplicativo.

Numa arquitetura de microsserviços, os serviços comunicam-se através de uma rede em vez de chamadas na memória. Embora essa dissociação permita o dimensionamento horizontal massivo e implantações independentes, ela também introduz uma grande vulnerabilidade: a rede não é confiável. A qualquer momento, um serviço downstream pode enfrentar uma breve falha na rede, um pico temporário de CPU, uma rápida contenção de bloqueio de banco de dados ou uma reinicialização de atualização contínua. Essas falhas temporárias são conhecidas como falhas transitórias.

Em uma arquitetura de microsserviços, um único aplicativo é dividido em dezenas ou centenas de serviços independentes e colaborativos. Embora esse design melhore a modularidade e a escalabilidade, ele também apresenta um grande risco: uma falha em um serviço pode se espalhar e derrubar todo o sistema. Se um serviço downstream ficar lento ou não responder, as solicitações recebidas para seus serviços upstream começarão a se acumular. Se todos compartilharem a mesma memória, CPU ou pool de threads, uma dependência lenta pode esgotar rapidamente todos os recursos disponíveis, causando falha em todo o aplicativo.

Em sistemas modernos nativos da nuvem, espera-se que os microsserviços façam muito mais do que executar a lógica de negócios. Eles devem lidar com o registro em log, gerenciar certificados SSL/TLS, coletar métricas, implementar mecanismos de nova tentativa e coordenar comunicações seguras com outros serviços. Se incorporarmos toda essa funcionalidade transversal diretamente na base de código de cada aplicativo, acabaremos com inchaço de código, acoplamento rígido e aprisionamento de linguagem.

Na engenharia de software moderna, os aplicativos monolíticos legados são um desafio comum. Com o tempo, uma base de código bem-sucedida fica tão grande e interconectada que fazer alterações simples se torna arriscado, as implantações levam horas e o dimensionamento de recursos individuais é praticamente impossível. Quando as equipes decidem modernizar seus sistemas migrando para microsserviços, elas enfrentam uma questão de alto risco: Como podemos reescrever o sistema sem interromper nossos negócios atuais?

Em uma arquitetura de microsserviços, nossos sistemas são divididos em dezenas de serviços pequenos e focados, como um serviço de usuário, um serviço de pedido e um serviço de produto. Mas quando se trata de exibir essas informações aos usuários, dispositivos diferentes têm necessidades muito diferentes. Um navegador da web em um computador desktop de alta velocidade deseja um painel rico cheio de tabelas, barras laterais e gráficos. Um aplicativo móvel em uma rede celular lenta deseja um layout simples e leve para economizar largura de banda e bateria. Um aplicativo smartwatch pode precisar apenas de uma única linha de texto.

A transição de um aplicativo único e monolítico para uma arquitetura de microsserviços resolve muitos problemas. Ele permite que as equipes trabalhem de forma independente, implantem serviços separadamente e dimensionem partes do sistema conforme necessário. No entanto, também introduz um novo desafio: como os clientes interagem com todos estes serviços independentes?

Em uma arquitetura monolítica, os componentes se comunicam por meio de chamadas de métodos na memória, que são instantâneas e altamente confiáveis. Ao migrar para uma arquitetura de microsserviços, entretanto, esses componentes são separados por limites de rede. A comunicação torna-se uma chamada de rede fora de processo (Comunicação entre processos ou IPC).

Quando as organizações fazem a transição de uma arquitetura monolítica para microsserviços, elas enfrentam uma questão crítica e de alto risco: Como traçamos os limites de nossos serviços? Em teoria, os microsserviços deveriam ser unidades soltas e desacopladas que podem ser desenvolvidas, implantadas e dimensionadas de forma independente. Na prática, porém, muitas equipes acabam construindo um monólito distribuído — um sistema em que os serviços estão tão fortemente acoplados que uma única mudança nos negócios exige a modificação e a implantação de vários serviços simultaneamente, agravando a latência da rede e os impasses de implantação.

Nos primórdios do desenvolvimento web, construir um aplicativo de software era simples: você escrevia o código, empacotava-o em um único arquivo executável ou implementável e executava-o em um servidor. Essa abordagem, conhecida como Arquitetura Monolítica, serviu bem ao setor por décadas. No entanto, à medida que os aplicativos se transformaram em plataformas empresariais massivas com centenas de desenvolvedores e milhões de usuários simultâneos, os monólitos começaram a mostrar seus limites. As implantações tornaram-se lentas e arriscadas, os bancos de dados tornaram-se gargalos e as bases de código tornaram-se complexas demais para serem compreendidas por qualquer desenvolvedor.