Como ensinar Scrum na prática #2

Em 2010 eu fiz um curso em SP de Scrum onde eu aprendi uma dinâmica para ensinar Scrum a outros times muito simples e divertida que consistia em, após estudar o básico da metodologia, em sintetizar o aprendizado em um folder, daí o nome da dinâmica que eu chamo de Agile Folder. Esta dinâmica pode ser conferida neste artigo aqui.

No artigo de hoje, vou falar de outra dinâmica que pode ser utilizada para ensinar Scrum na prática, oriunda de um treinamento de Agile Coach que fiz em 2018 com o Andy Barbosa, onde aprendemos alguns princípios em cima de uma Fábrica de Aviões. Obviamente estamos falando de aviões de papel. 🙂 Eu já fiz esse treinamento algumas vezes com times variados no Agibank, incluindo pessoas de áreas que não são de TI como Gestão de Pessoas, Backoffice, Marketing e tive excelentes resultados.

Dinâmica da Fábrica de Aviões
Dinâmica da Fábrica de Aviões

Se preparando

Reserve uma manhã ou tarde inteira, no mínimo, para realizar essa prática. Eu costumo fazê-la em uma manhã, em uma segunda-feira de preferência, que é para que eles tenham o restante da semana para aplicar o que foi aprendido.

Você precisará de um projetor digital ou televisor grande, uma sala que caiba toda sua equipe (ou faça turmas), um quadro branco ou mural para colar/fixar post-its/cartões (se não tiver, vai na parede mesmo), muitas folhas A4 (no mínimo 10 por pessoa) e tudo o que você encontrar para rabiscar: canetas, lápis, giz de cera, etc. É importante que as pessoas tenham mesas para trabalhar.

Instale algum software de cronômetro (como o CoolTimer) ou use algum Countdown Timer online ou em última caso tenha o seu celular carregado para usá-lo como cronômetro. E por fim, leve uma gravata com nó pronto e um boné e/ou apito. Se não tiver uma gravata, um blazer, jaleco ou paletó já resolve. Explicarei mais adiante.

A teoria

Crie uma apresentação de slides ou alguma outra dinâmica qualquer que lhe permita dar um overview do Scrum e de alguns artefatos que você pretende utilizar na equipe para melhorar os processos de desenvolvimento. Caso não tenha ideia alguma para a apresentação, use esse meu exemplo do Slideshare. Note como estruturei apenas tópicos e poucas frases, isso faz com que o palestrante tenha de ter mais domínio sobre o assunto e passe mais confiança de que você sabe do que está falando. Aqui no blog tenho dois posts que podem te ajudar a se preparar para esse momento, este e este.

A sua apresentação de slides deve abrir o treinamento e não deve demorar mais de 1h. Peça que sua audiência leia o Scrum Guide antes de vir para o treinamento e que tragam dúvidas e questionamentos. Use cada uma dessas dúvidas para iniciar debates e facilitar a colaboração de todos, visando que fique claro que somente terão sucesso se todos tentarem. Após a teoria, diga que farão uma prática para que eles vejam como funcionam as reuniões e os papéis e até mesmo os problemas que o Scrum não vai resolver e que eles terão de buscar soluções por conta própria.

Se o seu time não é composto por profissionais de projeto, talvez apresentar o conteúdo do Scrum Guide diretamente não fará sentido. Neste caso, sugiro introduzir os conceitos aos poucos, se baseando mais fortemente na essênca da agilidade, usando este meu outro artigo como apoio.

Explicando a Prática

A prática envolve o desenvolvimento de um produto que, em teoria, não é complexo: aviões de papel.

Diga para que se organizem em times de 4-5 integrantes, deixe os materiais de papelaria à disposição, mas não distribua nada, os times tem de ser auto-organizáveis. Explique que iremos simular a construção de aviões para entender como funciona a metodologia Scrum na prática e que quando estiver de gravata (coloque a gravata para mostrar) você estará no papel de cliente, autoridade sobre as prioridades do projeto e sempre preocupado com o ROI (retorno do investimento).

Agora, quando estiver de boné (tire a gravata e coloque o boné), você estará no papel do Agile Coach, ensinando o time a utilizar o Scrum corretamente e provocando as discussões. Sempre que algum time quiser falar com o Agile Coach ou com o cliente, deverá chamá-lo adequadamente para que você coloque a gravata ou boné e aja de acordo com sua persona.

Cada time deverá ter um Product Owner, que é quem fará a interface com o cliente e dará o aceite nos aviões, pois ele representa os interesses do cliente no dia a dia do projeto.

Cada time deverá ter um Scrum Master também, que pode ter mais de um papel caso o time seja muito pequeno (4 ou menos pessoas). Ele só não pode ser o P.O. e S.M., mas pode ser S.M. e Desenvolvedor. O Scrum Master dará o ritmo pro time, removerá impedimentos, cuidará dos materiais e do fluxo de trabalho combinado.

Os demais membros do time (2 a 3 pessoas) serão os desenvolvedores, responsáveis pelas atividades de confecção dos aviões: dobras, pintura, testes, etc. Deixe que se organizem os papéis antes de prosseguir e opcionalmente peça que criem nomes para seus times.

Executando a Prática

O próximo passo é entrar em acordo com todos de quanto tempo demorará a prática. Se você reservou a manhã inteira como eu mesmo faço, você terá 3h totais para o treinamento, sendo 1h para a teoria e 2h para a prática (já fiz prática em menos de 2h, mas ficam meio corridas demais). Explique que usará um cronômetro para contabilizar as cerimônias e consequentemente a duração das sprints e que devem respeitá-lo quando disser que a sprint acabou e coisas do tipo. Se você tem 2h, será possível fazer um bate papo ao final da sprint para conversarem sobre o que acharam.

Iremos rodar mais de uma sprint de construção de aviões e, para que tudo caiba dentro do tempo disponível, sugiro usar a seguinte divisão:

  • 10 minutos para a primeira Sprint Planning, sendo 5 para a explanação do cliente e 5 para o time entrar em acordo de como vão trabalhar e o quanto vão entregar;
  • 5 minutos para a construção dos aviões (e propositalmente pequeno e não faremos daily nesta dinâmica, pois teremos mais de uma retrospectiva);
  • 5 minutos para o Sprint Review de cada time
  • 5 minutos para um Sprint Retrospective geral

A prática começa com os primeiros 10 minutos de Sprint Planning, que nesse caso serão com a presença do cliente (você de gravata). Será feito apenas uma Sprint Planning geral, com todos os times escutando e fazendo perguntas. Você deve explicar que deseja um lote de 10 aviões em um tempo de 5 minutos, mas que todos eles devem ser iguais, devem voar e devem respeitar o modelo que você vai apresentar em um slide (escolha um modelo minimamente complexo, como o abaixo, em que a traseira possui um ângulo não tão óbvio de fazer e cujas dobras ficam escondidas na parte inferior do avião, ao invés da superior).

Avião de Papel
Avião de Papel

Avise que está buscando estes lotes com estes times mas que o contrato final só vai ser realizado com um deles, o que se sair melhor na dinâmica como um todo. Isso deve dar uma esquentada nas expectativas, mesmo sendo uma brincadeira bem simples.

Dê tantos detalhes quanto julgar necessários, mas tente deixar com que os participantes lhe questionem os detalhes mais importantes, como o tamanho do avião, adicione uma logomarca se quiser complicar, cores diferentes na fuselagem, que todos devem ser testados, etc. Uma das lições desse treinamento é que sempre o time tem de se comunicar com o cliente para que a “magia” aconteça. Então se eles não perceberem a necessidade de fazer as perguntas certas, o fracasso logo adiante vai ensinar isso a eles. Pense no avião final e deixe um pronto como referência, mas não mostre a eles ainda, deixe que eles tenham de interagir com você para descobrir.

Não tome mais do que 5 minutos nessa explanação inicial e diga que eles devem deliberar sobre o projeto do avião, o lote a ser feito, planejar as atividades dos membros, a ordem que farão e com o que se comprometem a entregar. Dê a eles 5 minutos para conversarem entre si (somente os membros do mesmo time) e conforme forem terminando, diga para chamarem o cliente para mostrar o resultado do seu planejamento. Lhes responda as últimas perguntas e anote o que cada time se comprometeu a entregar, isso é muito importante, pois você cobrará essa entrega mais tarde. Geralmente o excesso de confiança faz com que digam que entregarão tudo, mesmo sem terem muita ideia de como dividirão as tarefas e executarão o trabalho.

Rode os 5 minutos da sprint 1 com o timer visível para todos, bem como o modelo do avião (geralmente eu imprimo este último). Não faremos a Daily neste treinamento pois as retrospectivas serão bem próximas para gerar aprendizado e o tempo da sprint é muito curto. O Scrum Master, enquanto facilitador do processo deve avisar a todos quando os minutos estiverem terminando, deve controlar o tamanho do lote e auxiliar coordenando as atividades conforme combinado. Deixe em aberto a possibilidade de chamarem o cliente (coloque a gravata quando isso acontecer) ou o Agile Coach (boné) quando quiserem tirar dúvidas do produto (cliente) ou do processo (Agile Coach).

É comum que nesta primeira sprint os times façam aviões diferentes, não testem todos aviões, não façam validações com o cliente nem mesmo novas perguntas. Caso algum time tente renegociar prazos com o cliente não aceite, mas com muita relutância permita alteração no escopo por exemplo, mas sem exageros, como reduzir em algumas unidades o lote ou mudar algum padrão estético (pintura somente). A tendência é de falha nessa primeira tentativa, mas não avise eles disso, esse é o principal insumo para a retrospectiva que é feita ao término da sprint.

Quando os 5 minutos terminarem (o CoolTimer adiciona um efeito dramático à isso pois você pode escolher um MP3 bem barulhento para quando isso acontecer), diga a todos para pararem o que estão fazendo e que será feito agora a Sprint Review, onde os times apresentarão seu trabalho para o cliente (coloque a gravata) avaliar.

Para cada um dos times, analise criteriosamente o lote. Verifique se todos aviões seguem o modelo combinado, se fizeram todo o lote combinado, se todos estão iguais, etc. Se você reparou problemas na fabricação, como a ausência de testes, pergunte se alguém voaria em um avião que não foi testado. Se você reparou mudanças estéticas não acordadas, questione porque não lhe perguntaram se isso era permitido. E principalmente, se o time não entregou todo o lote, reclame, pois eles disseram que iam entregar.

O ponto que não deve ser esquecido aqui é comparar a entrega da equipe com o que ela havia prometido. No Scrum, o time define o tempo que irá levar para desenvolver as tarefas, e portanto, deve ser cobrado se não entregar o que o próprio time havia prometido. Use 4 minutos para avaliação e 1 minuto para reflexões com o grupo (quase uma retrospectiva coletiva, onde vai haver trocas de aprendizados).

Ao término das reviews, e consequentes frustrações de quem não entregou o que o cliente esperava, é hora da retrospectiva. Eu não vou falar aqui em detalhes dessa dinâmica porque já fiz isso em outro post aqui do blog, que falo somente de como conduzir retrospectivas de sprint que realmente funcionam.

Em linhas gerais, aqui é onde o time (e somente o time, com a mediação do Scrum Master) vai expor o que considerou que fluiu legal no desenvolvimento deste lote (deixe que eles falem), o que não fluiu tão bem assim e as ações que o time se compromete a executar na próxima sprint para que os mesmos erros não voltem a acontecer. Esse é o momento de maior aprendizado de toda prática e ele. Como todo bom erro, é na falha em que mais aprendemos e geralmente os times falham nessa prática.

Reserve 5 minutos para que eles decidam entre si como vão se organizar para a próxima sprint e passeie como Agile Coach pelos times para ajudar a tirar dúvidas do processo, instigá-los a melhorar o que está com problema (uma vez que os Scrum Masters de cada time não terão experiência pra isso) e cobre ao menos uma melhoria no processo de cada time.

Sprint #2

A segunda sprint vai começar e a dinâmica será muito parecida, com algumas poucas exceções.

Primeiro, o tempo de Sprint Planning será de 5 minutos ao invés de 10, uma vez que eles já se conhecem mais e tem pouca variação em relação à sprint anterior.

Segundo, introduza um novo modelo de avião ou uma variação no modelo anterior, como uma mudança de cor, uma dobra diferente, etc. Peça um lote de 10 aviões, mas sendo um número específico de cada modelo, pra complicar um pouco a vida dos times.

Desta vez espere muito mais perguntas e tentativas de negociação, pois eles estarão mais espertos e entenderão que o time tem mais poder do que estão acostumados. Seja teimoso, mas saiba ceder quando fizer sentido os argumentos e sempre explore a competição entre os times de uma maneira saudável, pois se um time entregar apenas um avião com qualidade top e outro time entregar cinco, você vai fechar contrato com o outro.

Após formalizar as entregas previstas com cada time, rode nova sprint de 5 minutos, faça nova review e finalize esta sprint com outra retrospectiva.

Quando acaba?

Você pode rodar tantas sprints quanto julgar necessário, mas no mínimo duas, para que tenham a oportunidade de aprender com seus erros e melhorar. É importante que a cada sprint sejam adicionadas novas complexidades, como por exemplo:

  • novos modelos de avião;
  • lotes variados;
  • que tal um avião extra solicitado no meio da sprint?
  • que tal uma mudança de requisito na confecção de um modelo no meio da sprint?
  • que tal a saída de um membro ou troca de membros entre os times?

A grande sacada não é ser simplesmente sádico, mas provocar diversas situações que acontecem no dia a dia dos times e que o treinamento já vai lhes preparar para reagir adequadamente.

Se tiver tempo, você pode introduzir no treinamento o conceito de Scrum Board também (um kanban bem simples), para gerenciar o fluxo de construção de múltiplos aviões, de múltiplos modelo oriundos de pedidos de múltiplos clientes (!!!). Uma sprint com esse grau de complexidade requer uma gestão mais eficiente e o kanban é uma ótima ferramenta para isso.

Tive a oportunidade de aplicar este mesmo treinamento em algumas dezenas de times do Agibank com um excelente grau de sucesso. Espero que você consiga usá-lo ou adapte-o às suas necessidades, mas que tenha sucesso também em melhorar os processos da sua empresa.

Outra ideia de treinamento de Scrum é transmitida pelo Jonas Salengue em seu livro Scrum em times de Infra, uma dinâmica baseada em construção de uma casa. Bem interessante também.

* 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!

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!