O que é um micro servico ou microservice?

Eu já falei sobre esse assunto antes aqui no blog, em outros artigos, sendo que o principal deles e que recomendo que leia na sequência é o Introdução a Arquitetura de Micro Serviços. A ideia do artigo de hoje é explorar mais o que é um microservice e lhe ajudar no entendimento e no desenvolvimento estudando alguns princípios básicos.

O objetivo principal de usar micro serviços (ou microservices) é ajudar o time de engenharia a entregar produtos mais rápido, de maneira mais segura e com qualidade mais alta. Pequenos serviços desacoplados permitem que os times tenham ciclos de desenvolvimento (sprints ou iterações) rápidos e com mínimo impacto ao resto do sistema.

Um micro serviço é uma pequena porção de software que roda de maneira independente, focada em um único e pequeno (daí o nome micro) conjunto de atividades dentro de um conjunto de serviços muito maior, formando uma arquitetura de micro serviços. Resumidamente é uma versão mais enxuta de web services e web APIs que tradicionalmente os desenvolvedores já faziam há anos.

Em uma arquitetura de micro serviços, múltiplos serviços fracamente acoplados (ou seja, com poucas ou nenhuma dependência entre si) trabalham juntos. Cada serviço foca em um único propósito e tem uma alta coesão (congruência, coerência) de comportamentos e dados relacionados. Note que esta última definição inclui três princípios básicos do design de micro serviços, que vamos ver a seguir.

Os três princípios do design de micro serviços

Quando estamos trabalhando em sistemas que usam a arquitetura de micro serviços devemos sempre ter em mente três princípios básicos.

Propósito Único: cada serviço deve focar em um único propósito e fazê-lo bem. Esta é regra é muito semelhante com o Single Responsibility Principle do acrônimo SOLID, muito utilizado em orientação à objetos.

Assim como o SRP do SOLID diz que uma classe Aluno deve se focar apenas em atender às necessidades de um aluno, o princípio do Propósito Único diz que um micro serviço ‘/alunos’ deve se focar apenas em realizar operações sobre alunos. Precisa lidar com questões financeiras do aluno? Crie outro micro serviço para focar nisso. Precisa fazer uma matrícula, onde tem de lidar com o aluno e com questões financeiras? Crie um terceiro micro-serviço que vai chamar os dois anteriores.

Garantir que cada micro serviço tenha um propósito único não é tão fácil e simples, mas é uma das dicas essenciais principalmente quando você está refatorando uma aplicação monolítica em micro serviços.

Baixo Acoplamento:  cada serviço não deve saber nada ou muito pouco dos outros serviços. Eles não devem compartilhar bibliotecas de código, ou apenas o que for genérico e essencial para ter o mínimo de código repetido. Eles devem ter suas próprias validações, seus próprios testes unitários e inclusive não precisam compartilhar sequer a mesma tecnologia ou o mesmo mecanismo de persistência.

Isso tudo para que uma mudança em um serviço não exija mudar outros serviços. Ou que um bug inserido no desenvolvimento de um serviço não atinja o código de outros também. Inclusive a comunicação entre serviços deve ser feita através de interfaces públicas e protocolos leves, funcionando em processos separados.

Este também é um princípio herdado da Orientação à Objetos, onde trabalhamos Loose Coupling ou Low Coupling dentro dos design patterns como sendo um objetivo desejável para garantir boas arquiteturas, muito mencionado no clássico Padrões de Arquitetura de Aplicações Corporativas, do Martin Fowler.

Alta Coesão: cada serviço encapsula todos os comportamentos e dados relacionados juntos. Isso garante que se precisarmos construir uma nova feature sobre um mesmo domínio ou propósito, todas as mudanças devem ser localizadas em um único serviço.

Note que o próprio princípio do Propósito ou Responsabilidade Única dá os subsídios necessários para garantir uma alta coesão, outro tema bem forte nos design patterns da orientação à objetos.

No gráfico abaixo, extraído da Internet, temos a relação entre estes três princípios e como eles se interseccionam para gerar a base desejada para a construção de micro serviços que atendem ao padrão deste tipo de arquitetura.

Princípios de Micro Serviços
Princípios de Micro Serviços

Quando modelamos microservices nós temos que ser disciplinados em seguir ao menos estes três princípios básicos de design. É o único caminho para atingir o potencial pleno de uma arquitetura de microservices. Deixar qualquer um deles de lado fará com que o seu padrão se torne um antipattern ou anti-padrão, algo que vai te levar a resultados ruins, ao invés do que você espera.

Sem um propósito único, por exemplo, cada microservice pode terminar fazendo muitas coisas, crescendo em uma arquitetura de vários serviços monolíticos. Isso fará com que, além de não colher os benefícios completos de uma arquitetura de microservices, você terá um custo operacional alto para manter isso.

Sem um acoplamento baixo, mudanças em um serviço vão afetar outros serviços, lhe impedindo de liberar releases de maneira rápida, frequente e livre de bugs, que é justamente o benefício principal de uma arquitetura dessas. Mais importante ainda, problemas causados por um alto acoplamento podem ser desastrosos como inconsistências de dados ou mesmo perda deles.

E por fim, sem alta coesão, acabamos gerando uma aplicação monolítica distribuída, muito comum no passado e que há décadas sofremos com legados deste tipo onde, apesar de termos muitos serviços, só podemos aplicar novas features em produção se atualizarmos e implantarmos todos eles em produção, muitas vezes em uma ordem específica e ao mesmo tempo. Na minha opinião e de outros engenheiros com ainda mais experiência, isso é pior do que ter uma grande aplicação monolítica porque a complexidade e o custo operacional disso é muito alto.

Curso Node.js e MongoDB
Curso Node.js e MongoDB

O que não é um micro serviço?

Muitas vezes fica mais fácil de entender o que algo é quando definimos o que ele não é, certo?

Um micro serviço não é um serviço que tem um número pequeno de linhas de código ou que faz ‘micro tarefas’. Esta confusão vem do próprio nome, mas não é uma regra e nem é o objetivo desta arquitetura. Os serviços devem possuir a complexidade e quantidade de linhas de código necessárias desde que atendam os três princípios anteriormente descritos.

Um micro serviço não é um serviço construído com a tecnologia mais bacana e hipster que o mercado oferece no momento. Embora a arquitetura de micro serviços te permita sim testar novas tecnologias de maneira muito rápida e fácil, não é um objetivo primário desta arquitetura. Está completamente ok usar qualquer tecnologia que atenda aos princípios anteriores e não faz sentido algum refatorar todos seus micro serviços cada vez que uma nova stack aparece no mercado.

Um micro serviço não tem de ser sempre programado do zero. Quando você está iniciando um processo de refatoração de uma aplicação monolítica, é muito comum que você extraia códigos da aplicação original para os micro serviços e não há problema algum nisso, desde que respeite os três princípios.

Então por hoje é isso, espero que tenha gostado e, caso queira saber mais sobre o assunto, recomendo meu curso de Node.js e MongoDB ou o meu livro sobre micro serviços abaixo.

Dicas para refatorar um monolito em micro serviços

Erroneamente creditei a fonte original em Inglês à Rising Stack, mas na verdade é da Nginx.

O processo de transformar uma aplicação monolítica em micro serviços é uma forma de modernização de aplicação, algo que os desenvolvedores já fazem há décadas. Como resultado, existem algumas ideias que você pode reutilizar quando estiver refatorando uma aplicação em microservices. Se você não sabe o que é um microservice, recomendo este artigo primeiro.

Uma estratégia é não fazer uma reescrita Big Bang, ou seja, esqueça a ideia de reescrever toda aplicação do zero, direcionando todos os esforços do time para isso. Embora muitas vezes isso soe interessante, é algo extremamente arriscado e geralmente resulta em problemas. Como Martin Fowler já disse algumas vezes, em uma tradução livre, a única garantia de um Big Bang é que algo vai explodir!

Ao invés de fazer uma reescrita Big Bang, você deve incrementalmente refatorar sua aplicação monolítica. Construa uma aplicação de microservices gradualmente, rodando cada novo microservice em conjunto do monolito original. Com o passar do tempo, a quantidade de funcionalidades implementadas em microservices versus a quantidade de funcionalidades remanescentes no monolito vai evidenciar que o mesmo encolheu ao ponto de que em algum momento ele irá sumir.

Martin Fowler refere-se à essa estratégia de modernização de Strangler Application (Aplicação Estranguladora). O nome vem da vinha estranguladora, uma espécie de cipó que cresce em árvores tropicais. Esta vinha vai se fixando na árvore original, consumindo seus recursos enquanto ela própria cresce mais rápido que sua hospedeira, não raro causando a morte da árvore original e deixando no lugar um monte de vinhas no formato de uma árvore.

Estratégia #1 – Pare de Cavar

A Lei dos Buracos (Law of Holes) diz que toda vez que você estiver em um buraco, você deve parar de cavar. Este é um ótimo conselho quando sua aplicação monolítica se tornar ingerenciável. Em outras palavras, você deve parar de tornar seu monolito maior. Se tiver de implementar uma nova funcionalidade você não deve adicionar este código ao monolito. Ao invés disso, a grande ideia com esta estratégia é colocar o novo código em um microservice próprio pra isso. O diagrama a seguir, do site Nginx, mostra a arquitetura do sistema depois de aplicar esta abordagem.

To start migrating from a monolith to a microservices architecture, implement new functionality as microservices; continue routing requests for legacy functionality to the monolith until there is a replacement microservice [Richardson microservices references architecture]

Repare no uso de um request router à frente de ambas soluções (monolito e microservice) que pode facilmente ser um API Gateway. Esta camada de software recebe as requisições originais e verifica se elas devem ser direcionadas para o legado ou para o microservice.

O outro componente que surge com esta arquitetura híbrida foi chamado de Glue Code no diagrama e nada mais é do que as dependências responsáveis por acesso a dados. Geralmente o serviço irá usar libs e componentes de acesso a dados do monolito original. Com isso em mente, esse glue code pode usar uma de três estratégias:

  • Invocar uma API remota fornecida pelo monolito;
  • Acessar a base de dados do monolito diretamente;
  • Manter sua própria cópia da parte da base de dados que lhe interessa, a qual deve estar sincronizar com a base do monolito;

Este glue code muitas vezes é chamado de camada anti-corrupção. Isto porque este glue code evita que o micro serviço seja poluído por conceitos do modelo de domínio legado. O termo camada de anti-corrupção foi introduzido pela primeira vez no livro Domain Driven Design do Eric Evans e depois foi refinando em um white paper. Desenvolver uma camada anti-corrupção não é algo exatamente trivial, mas é essencial se quiser sair do inferno do monolito.

Implementar novas funcionalidades como um micro serviço tem uma série de benefícios. Essa estratégia impede que seu monolito se torne ainda mais ingerenciável, ao mesmo tempo que permite que o serviço possa ser desenvolvido, implantado e escalado de maneira independente do monolito. A cada serviço novo que você cria, você experimenta um pouco mais dos benefícios desta arquitetura.

Entretanto, esta abordagem não endereça os problemas do monolito. Para consertar estes problemas você precisa quebrar o monolito, o que falaremos a seguir.

Curso Node.js e MongoDB
Curso Node.js e MongoDB

Estratégia #2 – Separe Frontend e Backend

Uma estratégia que ajuda a encolher a aplicação monolítica é separar a sua camada de apresentação da sua lógica de negócio e do acesso a dados também. Uma típica aplicação corporativa consiste de ao menos três diferentes tipos de componentes:

  • Presentation layer – Componentes que lidam com requisições HTTP e implementam APIs ou UIs. Em uma aplicação que tenha uma interface de usuário muito sofisticada terá uma quantidade de código de front-end substancialmente grande.
  • Business logic layer – Componentes que são o core da aplicação e implementam as regras de negócio.
  • Data‑access layer – Componentes que acessam outros componentes de infraestrutura como bancos de dados e message brokers.

Geralmente existe uma separação muito clara entre a lógica de apresentação em um lado e as regras de negócio e de dados em outro. Geralmente a sua camada de negócio vai ter uma API consistindo de uma ou mais fachadas/interfaces que por sua vez encapsulam os componentes de lógica de negócio. Esta API é o que permite fazer a separação do seu monolito em duas aplicações menores. Uma aplicação vai ser o front-end, a outra o back-end. Uma vez separados, o front-end irá fazer chamadas remotas ao back-end, sendo que o diagrama abaixo mostra como isso fica, antes e depois:

Refactor a monolith into two apps: one for presentation logic and another for business and data-access logic [Richardson microservices reference architecture]

Separar um monolito dessa maneira tem dois benefícios principais. Ele permite que você desenvolva, implante e escale duas aplicações de maneira independente. Principalmente quando se fala de front-end e rápidas iterações, testes A/B, etc. Outro benefício é que você combina com a estratégia #1 ao fornecer uma API do monolito para ser consumida pelos novos micro services que você desenvolver.

Esta estratégia, no entanto, é somente uma solução parcial. É bem comum que você troque um problemão gigante por dois problemas menores, mas que ainda são um problema a ser resolvido. Você terá de usar uma terceira estratégia para eliminar os monolitos restantes.

Estratégia #3 – Extrair Serviços

A terceira técnica de refatoração é transformar os módulos existentes dentro de um monolito em micro services standalone. Cada vez que você extrai um módulo e o transforma em um serviço, o monolito encolhe. Uma vez que você tenha convertido muitos módulos, o monolito irá parar de ser um problema. Ou ele irá sumir ou vai virar apenas um serviço por si só.

Priorizando quais módulos vão virar serviços

Uma aplicação monolítica grande geralmente terá dezenas ou centenas de módulos, todos candidatos para extração. Saber quais módulos converter primeiro pode ser desafiador. Uma boa abordagem é começar com alguns módulos que são fáceis de extrair. Isto vai lhe dar experiência com microservices em geral e com o processo de extração em particular. Depois que você extrair estes módulos mais fáceis, poderá partir para os mais importantes.

Converter um módulo em um microservice é algo que tipicamente requer tempo. Uma técnica de priorização é priorizar aqueles que mudam com frequência. Uma vez que você tenha convertido um módulo desses para um serviço, você pode desenvolver e implantar ele de maneira independente do monolito, o que vai acelerar o seu desenvolvimento.

Outra abordagem interessante é extrair os módulos que possuem requisitos significantemente diferentes do resto do monolito. Por exemplo, é útil pegar aquele módulo que usa uma base de dados in-memory e transformá-lo em um microservice, o qual poderá ser implantado em um servidor com muita memória. Da mesma forma, aquele módulo que consome muita CPU pode ser transformado em um microservice e feito deploy em um servidor com muito mais CPU do que RAM. Conforme você vai extraindo estes módulos específicos, você vai ver como se tornará mais fácil escalar os mesmos.

Como extrair um módulo

O primeiro passo ao extrair um módulo é definir a interface entre o módulo e o monolito. Geralmente será uma API bidirecional pois é comum o monolito precisar de dados do microservice e vice-versa. Se a sua lógica de negócio do monolito estiver com muitas associações entre suas classes talvez seja difícil de expor apenas o que importa para o microservice utilizar e não é raro que uma refatoração interna no monolito seja necessária para continuar avançando com essa estratégia de extração.

O diagrama abaixo mostra o passo a passo da extração de um módulo de um monolito para um microservice:

Extract a module/microservice from a monolith by defining a coarse-grained interface between the module and the monolith [Richardson microservices reference architecture]

Neste exemplo, o módulo Z é o candidato a ser extraído. Seus componentes são usados pelos módulos X e Y. O primeiro passo de refatoração é definir um par de APIs de alto nível. A primeira interface é de entrada e é usada pelo módulo X para invocar o Z. A segunda é uma interface de saída usada pelo módulo Z para invocar o Y.

O segundo passo da refatoração transforma o módulo em um serviço separado. Uma vez que você tenha extraído um módulo, é mais um serviço que você tem que lhe permite desenvolver, implantar e escalar mais facilmente do restante do monolito. Você poderá inclusive reescrever este serviço do zero mais tarde, uma vez que o módulo já foi isolado.

Cada vez que você extrair um novo serviço, estará um passo mais perto de ter uma aplicação 100% em microservices. Com o passar do tempo, seu monolito vai encolher e a virada de chave entre as arquiteturas vai se tornar algo natural e inevitável.

Até a próxima!

Este artigo é uma adaptação livre do original Refactoring a monolith into microservices, de Chris Richardson.

Curtiu o post? Então clica no banner abaixo e dá uma conferida no meu livro sobre microservices com Node.js!

Utilizando o Scrum em um time que não é de desenvolvimento

scrum4infra

No artigo de hoje abri espaço para o consultor de TI e gerente de projetos na Umbler, Jonas Salengue, falar da sua experiência implementando Scrum em times que não eram de desenvolvimento. Jonas é um profissional com muitos anos de mercado e já trabalhou em multinacionais, como a HP. Recentemente lançou um livro sobre Scrum para equipes de infraestrutura que está disponível à venda na Amazon.

Olá, sou o Jonas, consultor de TI e analista de infraestrutura. Sou um grande apreciador de desafios e foi dentro de um desafio que tive o contato na prática com o Scrum pela primeira vez. Recebi o pedido de ajuda de um líder de uma equipe de infraestrutura que enfrentava dificuldades para controlar as atividades do dia-a-dia e projetos da sua área, então decidi apostar no Scrum como solução para este problema.

Antes de relatar alguns detalhes desta experiência, gostaria de agradecer ao Luiz (autor do blog) por este espaço. O Luiz é um com certeza uma referência no Scrum com algumas obras excelentes disponíveis na Amazon.

Utilizar o Scrum, independente da característica do time, deve ser um projeto com planejamento e adaptações adequadas. Dificilmente alguém utilizará 100% do que o framework descreve, pois isto acarretaria uma série de complicações, principalmente a resistência e, consequentemente, a desistência das pessoas. Saber como abordar os conceitos do scrum foi fundamental para que o time de infraestrutura “comprasse” a ideia de utilizá-lo. Para tal, utilizei uma dinâmica na qual descrevo em detalhes no livro, porém, resumidamente, trata-se da construção de uma maquete de uma casa utilizando os eventos, papéis e artefatos do framework.

Importante é que para a realização desta dinâmica, não foram utilizados os termos “técnicos” do Scrum, por exemplo, o backlog do produto nós o abordamos como “lista geral”, a sprint como “período de execução” e o backlog da sprint como “lista de execução”. Talvez seja mais interessante no início utilizar palavras e expressões que façam sentido ao pé-da-letra, pois, para esta experiência, fez toda a diferença. O próprio papel do Scrum Master foi apresentado como “facilitador” e na execução da dinâmica o time concluiu o porquê deste nome.

Após este trabalho de construção dos conceitos, garantimos que todos os integrantes do time estavam falando a mesma língua. Dai sim, começou-se o planejamento para adequar o framework à realidade do time de infra que possui características distintas, principalmente devido ao fato de prestarem suporte, ou seja, executarem várias demandas no dia-a-dia que concorrem com a execução das atividades planejadas dos projetos da área.

Basicamente utilizamos os eventos: planejamento da sprint, reuniões diárias, revisão e retrospectiva. Como artefatos definimos o backlog do produto e o backlog da sprint durante o planejamento desta. Inicialmente eu realizei o papel de Scrum Master, participando ativamente durante as 4 primeiras sprints do time. Ah, importante lembrar que desde o início utilizamos métricas através da pontuação das atividades com a técnica de planning poker. Essa técnica foi utilizada inclusive na dinâmica da casa para que o time já se tivesse contato e fosse desenvolvendo seu poder de estimar e controlar o progresso.

O resultado final desta adaptação do scrum para um time de infraestrutura foi um sucesso. Apesar de ter sido uma consultoria, algo temporário, mantenho contato com o time até hoje e continuam utilizando o framework. Eles mantém o controle do progresso dos projetos e demandas utilizando as métricas da pontuação das tarefas, construindo o gráfico burndown para representar as entregas planejadas versus o burnup que representa as demandas que surgem e devem ser atendidas durante as sprints.

Bem, resumidamente o livro aborda as questões que comentei acima, porém é claro, com muito mais detalhes e uma narrativa na qual procurei tornar interessante.

Confiram a obra em www.scrum4infra.com

Abraços e até!

Jonas

Resenha

Eu li recentemente o livro do Jonas (sim, eu estava devendo a leitura deste livro há muito tempo) e ele é bem interessante. Diferente dos livros tradicionais sobre métodos ágeis, o Scrum em Equipes de Infraestrutura é uma narrativa interessante das consultorias realizadas por ele e pelo irmão dele a uma empresa, cujo nome e funcionários foram alterados para evitar problemas legais.

Ao invés de ater-se meramente às técnicas, Jonas relata muito bem as percepções dos envolvidos, as ansiedades, angústias e sim, as práticas utilizadas também. Tudo isso de uma forma que seja possível reproduzir o passo-a-passo que ele utilizou com o cliente, seja na íntegra ou apenas parcialmente.

O livro é ricamente ilustrado com diagramas, gráficos e imagens de apoio que tornam muito fácil abstrair o que é dito e principalmente os artefatos utilizados nesta pequena transformação ágil que ele relata.

Não é um livro denso, o que facilita a leitura mas que pode desanimar quem busca uma resposta para todas perguntas para este tópico tão polêmico que é Scrum além do desenvolvimento de software. É sim uma leitura rápida, envolvente, divertida e muito didática. Recomendo a quem estiver assumindo a missão de colocar um pouco de métodos ágeis em times que tradicionalmente não vêem valor nessas práticas por não lidarem com desenvolvimento de software.

Deixem seus comentários para o Jonas no espaço abaixo, que eu aviso ele para ler!

* OBS: curtiu o post? Então dá uma olhada no meu livro de Scrum e Métodos Ágeis clicando no banner abaixo pra aprender muito mais!