<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Rafael Gonzaga on Medium]]></title>
        <description><![CDATA[Stories by Rafael Gonzaga on Medium]]></description>
        <link>https://medium.com/@rafaelgss?source=rss-b09ac8eb5393------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*R-A298mUzGzo3AfF72FSbA.jpeg</url>
            <title>Stories by Rafael Gonzaga on Medium</title>
            <link>https://medium.com/@rafaelgss?source=rss-b09ac8eb5393------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 17:26:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rafaelgss/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Microsserviços Autônomos]]></title>
            <link>https://medium.com/@rafaelgss/microsservi%C3%A7os-aut%C3%B4nomos-16402b207a8d?source=rss-b09ac8eb5393------2</link>
            <guid isPermaLink="false">https://medium.com/p/16402b207a8d</guid>
            <category><![CDATA[outbox]]></category>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[architectural-design]]></category>
            <category><![CDATA[micro-serviços]]></category>
            <dc:creator><![CDATA[Rafael Gonzaga]]></dc:creator>
            <pubDate>Fri, 06 Mar 2020 22:43:42 GMT</pubDate>
            <atom:updated>2022-01-28T04:04:28.031Z</atom:updated>
            <content:encoded><![CDATA[<h4>Outbox Pattern</h4><p>Em uma arquitetura de microsserviços boa parte de sua complexidade está na consistência dos dados, ou seja qual a melhor forma de comunicar os microsserviços de forma que um consiga dados do outro? Como expor em um single endpoint a relaçao entre um recurso e outro? Como lidar com 2PC/Saga? Veja isso e mais ̶n̶o̶ ̶D̶o̶m̶i̶n̶g̶o̶ ̶E̶s̶p̶e̶t̶a̶c̶u̶l̶a̶r̶ neste artigo.</p><p>Bom, antes de adentrarmos nas nuances da solução para as perguntas acima, vamos entender qual é realmente o problema enfrentado.</p><p><strong>👋 Me siga no </strong><a href="https://twitter.com/_rafaelgss"><strong>Twitter</strong></a><strong>!</strong></p><h3>O Contexto</h3><p>Quando se utiliza uma arquitetura voltada para microsserviços, normalmente o primeiro fato que nos vem a cabeça é separar os serviços por domínio, ou seja, tomando como exemplo um ecommerce, poderiamos ter um microsserviço de <strong>Users</strong> e outro de <strong>Orders</strong>. Portanto, vamos imaginar esse cenário.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/620/0*2O67Zzbi0JeY0ldX.png" /></figure><h3>O Problema</h3><p>Imagine uma situação onde é necessário retornar a relação entre <strong>users</strong> e <strong>orders</strong>. Normalmente haverá dois possíveis meios:</p><ul><li>Realizar dois requests (um para capturar usuários e outro para capturar as orders de cada um.)</li><li>Criar um BFF (Backend For Front-end) que faça o passo acima</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_9d5pHvI-YOpTBoy.png" /></figure><p>Porém, e se nossa regra de negócio for que para cada <strong>novo user</strong> precisemos criar uma <strong>nova order</strong>?</p><blockquote>“Mas isso é fácil, é só propagar um evento no message broker quando criar um usuário”</blockquote><p>Boa! Mas, se o processo de criar uma <em>order</em> falhar, o usuário também deve ser removido…</p><blockquote>“É só usar o <a href="https://microservices.io/patterns/data/saga.html">Pattern Saga</a>”</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*opMbCQqGwdKvYC7L.png" /></figure><p>Bom, se você precisar concatenar outros serviços nessa regra sua arquitetura vai ficar com uma complexidade exponencial. Pra isso existe o <strong>Pattern Outbox</strong>; ao decorrer desse artigo, vamos entender porque lidar com consistência eventual é bom e te permite escalar em um domínio cheio de regras de negócio.</p><p>Microsserviços normalmente possuem seu próprio local data store, em nosso contexto, Users possuí sua database, assim como Orders. Entretanto, no exemplo acima lidamos com dual write, ou seja, a simples criação de usuários pode levar a possíveis inconsistências. O motivo é que não podemos ter uma transação compartilhada que abranja o banco de dados do serviço, bem como o Message Broker, pois o último não pode analisado em transações distribuídas. Portanto, em circunstâncias infelizes e possíveis, pode acontecer que seja criado o novo usuário no banco de dados local, mas não tenha enviado a mensagem correspondente ao Message Broker (por exemplo, devido a algum problema de rede). Ou, ao contrário, podemos ter enviado a mensagem para o Broker, mas não conseguimos manter o usuário no banco de dados local.</p><p>Ambas as situações são indesejáveis; isso pode fazer com que nenhuma order seja criada para um usuário aparentemente criado com sucesso. Ou uma order é criada, mas não há nenhum vestígio sobre o usuário de compra correspondente no próprio serviço de users.</p><p><strong>Lembre-se:</strong> Um dos principais conceitos de microsserviços é a resiliência, portanto, se seu serviço depende de outros para “funcionar”, não há uma arquitetura de microsserviços, e sim uma <strong>arquitetura microlítica</strong> como chamo carinhosamente.</p><h3>Teorema CAP</h3><p>Este Teorema afirma que é impossível que o armazenamento de dados distribuídos forneça simultaneamente mais de duas das três garantias seguintes:</p><ul><li>Consistência</li><li>Disponibilidade</li><li>Partição tolerante a falhas</li></ul><h3>Consistência</h3><p>Uma garantia que cada nó em um cluster distribuído <strong>retorne a escrita mais rescente</strong>. Consistência refere-se a cada cliente ter a mesma visualização dos dados. Existem vários tipos de modelos de consistência. A consistência no CAP (usada para provar o teorema) refere-se à linearizabilidade ou consistência sequencial, uma forma muito forte de consistência.</p><h3>Disponibilidade</h3><p>Cada nó que não falha retorna uma resposta para <strong>todas</strong> as solicitações de leitura e escrita em um período de tempo razoável. Para se considerar disponível, todos os nós (em ambos os lados de uma partição de rede) <strong>devem</strong> responder em um curto espaço de tempo.</p><h3>Partição tolerante a falhas</h3><p>Um sistema que é <em>“partição tolerante a falhas”</em> pode sustentar quaisquer quantidade de falhas na rede que não resulta em uma falha na rede completa. Os dados são replicados entre os nós/rede para manter o sistema ativo por interrupções intermitentes. Ao lidar com sistemas distribuídos modernos, <strong>a Tolerância de Partição não é uma opção, é uma necessidade</strong>. Portanto, temos que <em>negociar</em> entre consistência e disponibilidade.</p><h3>Escolhendo</h3><p><strong>Consistência + Disponibilidade:</strong> Comumente utilizado em sistemas que necessitam de forte consistência e alta disponibilidade, chamados também de abordagem Otimista, pois partem do pressuposto que as escritas NUNCA falham.</p><p><strong>Consistência + Partição Tolerante:</strong> Sistemas que optam por essa estratégia, precisam abrir mão da disponibilidade. Existe uma palavra, bastante importante nesse contexto, chamada: Conscenso. Em sistemas do tipo CP, caso exista um particionamento a escrita — como mencionado anteriormente, pode sim ser rejeitada/negada.</p><p><strong>Disponibilidade + Partição Tolerante:</strong> Utilizado quando a necessidade maior é disponibilidade e escalabilidade, portanto, abrindo mão da consistência, lidando com a famosa <strong>Consistência Eventual</strong>, ou seja, deixando seus dados serem consolidados entre nós indefinidamente. — <em>Será sobre essa escolha que vamos discorrer</em>.</p><h3>Youtube Use Case</h3><p>O Youtube precisa mentir para seus usuários, e explico o porque. Quando lidamos com a massa de dados que o Youtube possuí, falar em escalabilidade é uma das tarefas mais difíceis, portanto, seguindo o Teorema CAP, devemos optar por <strong>Disponibilidade e Partição Tolerante</strong> sem titubiar. Pois, imagina centralizar os dados em um local só ou fazer com que eventualmente apareça um erro na tela do usuário? Portanto, vamos a algumas opções óbvias:</p><ul><li>Compartilhar a mesma base de dados para quaisquer aplicação — E está será o eterno problema.</li><li>Deixar um servidor processando as requisições para recuperar os dados. — E este servidor será o problema.</li><li>Manter mais de um servidor de dados, fazendo com que eventualmente os dados sejam consolidados entre todos os servidores. — <strong>Winner</strong></li></ul><p>É por isso que se duas pessoas entrarem em um vídeo em alta ao mesmo tempo irão ver visualizações com números distintos (claro, se cairem em nós distintos).</p><blockquote>“Mas como lidar com a Consistência Eventual, e se precisar do dado atualizado?”</blockquote><p>Bom, como dito anteriormente, nada é uma bala de prata, tudo depende do problema arquitetural a se resolver. O Domínio Users sempre contará com o dado atual <strong>como se fosse o mais recente</strong>, afinal ele não conhece outros domínios. Portanto, se por alguma razão seja necessário obter os dados em <strong>TEMPO REAL</strong> pode ser que esta abordagem não sirva para a resolução do problema — Mas cá entre nós, na maioria das vezes não é necessário nem escalável tal necessidade.</p><h3>Consistência Eventual</h3><blockquote>“Eventual consistency is a consistency model used in distributed computing to achieve high availability that informally guarantees that, if no new updates are made to a given data item, eventually all accesses to that item will return the last updated value. Eventual consistency, also called optimistic replication, is widely deployed in distributed systems, and has origins in early mobile computing projects. A system that has achieved eventual consistency is often said to have converged, or achieved replica convergence. Eventual consistency is a weak guarantee — most stronger models, like linearizability are trivially eventually consistent, but a system that is merely eventually consistent does not usually fulfill these stronger constraints.”<em> — </em><a href="https://en.wikipedia.org/wiki/Eventual_consistency"><em>Wikipedia</em></a></blockquote><p>A ideia desse padrão é que quaisquer informações que o serviço X necessite contenha em seu próprio domínio. Em nosso contexto, vamos imaginar que precisamos do <strong>nome completo </strong>do usuário ao criar uma <strong>Order</strong>, portanto, para o <strong>domínio Order</strong> usuário é apenas um conjunto de <strong>name</strong> onde entra o chamado <a href="https://martinfowler.com/bliki/BoundedContext.html"><strong>Bounded Context</strong></a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9xny4ktjcpH-AEpS.png" /></figure><p>Perceba que os dados estarão replicados em ambos serviços ( <em>name</em>), e isso é bom! Dessa forma garantimos a consistência local e temos a clamada transação local.</p><h3>Consolidandos os Dados</h3><p>Idealizamos, e agora?</p><p>Agora, apresentarei o famigerado Debezium e seu poder de <a href="https://en.wikipedia.org/wiki/Change_data_capture">CDC (Change Data Capture)</a></p><p>A ideia do Debezium é simples, ele atua no topo do Apache Kafka, ou seja imagine uma trigger de inserção na base de dados, escutando quaisquer mudanças na tabela (dependendo da configuração) e as replicando no broker. Ou seja, por definição expomos os dados que quisermos — Amplamente utilizado uma table <strong>outbox</strong> com o schema abaixo <a href="https://thoughts-on-java.org/outbox-pattern-hibernate/">ref</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yEqfbLwcxVgXi498.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JciqEVfjyrb7Uii6.png" /></figure><p>Não me prolongarei sobre como o Debezium faz, pra isso existe sua excelente <a href="https://debezium.io/documentation/">documentação</a>.</p><p>Para mostrar na prática, fiz um exemplo bem simples <a href="https://github.com/RafaelGSS/microservice-debezium-outbox">aqui</a> basta seguir as instruções do README, e voilà!</p><p>Qualquer dúvida ̶g̶u̶a̶r̶d̶e̶ ̶p̶r̶a̶ ̶v̶o̶c̶ê̶ fale comigo em qualquer <a href="https://rafaelgss.github.io/portfolio/">rede social</a>.</p><p><em>Originally published at </em><a href="https://blog.rafaelgss.com.br/microsservicos-autonomos"><em>https://blog.rafaelgss.com.br/</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=16402b207a8d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Comunicação entre Microserviços: Async]]></title>
            <link>https://medium.com/@rafaelgss/comunicacao-entre-microservices-async-ed3e5897ba6?source=rss-b09ac8eb5393------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed3e5897ba6</guid>
            <category><![CDATA[brasil]]></category>
            <category><![CDATA[micro-serviços]]></category>
            <category><![CDATA[asynchronous]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[rabbitmq]]></category>
            <dc:creator><![CDATA[Rafael Gonzaga]]></dc:creator>
            <pubDate>Thu, 05 Sep 2019 13:42:32 GMT</pubDate>
            <atom:updated>2022-01-28T04:03:58.518Z</atom:updated>
            <content:encoded><![CDATA[<h3>Comunicação entre microsserviços: Async</h3><p>Introdução ao RabbitMQ e seus feitos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*ypEfwY90R9-AvcBCnMbPGQ.png" /></figure><p>Em uma arquitetura voltada para microsserviços, dois dos seus principais conceitos chaves são: <strong>escalabilidade e resiliência</strong>. Dito isso, é bem comum que haja a <strong>necessidade </strong>dos microsserviços se comunicarem de alguma forma, seja para requisitar recursos ou baseada em <a href="https://en.wikipedia.org/wiki/Event-driven_architecture">Event Driven</a>. Então, como fazer isso sem afetar <strong>diretamente</strong> a resiliência ?</p><blockquote>Esse artigo é o primeiro de uma série que pretendo fazer sobre algumas formas de comunicação entre os microsserviços.</blockquote><p><strong>👋 Me siga no </strong><a href="https://twitter.com/_rafaelgss"><strong>Twitter</strong></a><strong>!</strong></p><p>Primeiro de tudo, essa abordagem <strong>não</strong> é uma bala de prata, tudo vai depender do problema na qual sua arquitetura se propõe a resolver.</p><p>Uma coisa é fato, <strong>a comunicação é complexa</strong> e nesses casos a <strong>transparência é essencial</strong>. Usar os padrões corretos para realizar tal comunicação pode lhe ajudar a escalar e resolver grande parte dos problemas que virão <em>(sim, haverão diversos problemas!). </em>As vezes a boa e velha comunicação síncrona via HTTP pode resolver seu problema (mesmo perdendo um “pouco” em resiliência).</p><p>Neste artigo tentarei mostrar porque a comunicação via <a href="https://en.wikipedia.org/wiki/Message_broker"><strong>message brokers</strong></a> tem ganhado bastante espaço, com isso nomes como: <em>RabbitMQ, Kafka, ActiveMQ </em>apareceram e vem sendo amplamente usados. <br>Especificamente neste artigo tratarei sobre <a href="https://rabbitmq.com/"><strong>RabbitMQ</strong></a>, mas alguns desses patterns também são usados nas outras tecnologias de messageria.</p><blockquote>Lembrando: se sua necessidade é lidar com microsserviços com o <strong>máximo de resiliência,</strong> verifique uma arquitetura baseada em <a href="https://microservices.io/patterns/data/event-sourcing.html">Event Sourcing</a>.</blockquote><h3>O que é mensageria/message brokers ?</h3><blockquote>A <strong>message broker</strong> (also known as an <strong>integration broker</strong> or <strong>interface engine</strong><a href="https://en.wikipedia.org/wiki/Message_broker#cite_note-GartnerIB-1">[1]</a>) is an intermediary computer <a href="https://en.wikipedia.org/wiki/Modular_programming">program module</a> that translates a message from the formal messaging protocol of the sender to the formal messaging protocol of the receiver. — <a href="https://en.wikipedia.org/wiki/Message_broker">Wikipedia</a></blockquote><p>Em um breve resumo, se trata de um intermediário de comunicação — Pense na logística para enviar uma carta (<em>finja que isso ainda é usado</em>), então de forma resumida os principais passos são:</p><ol><li>Você escreve a carta.</li><li>Você a coloca na caixa de correio com um determinado destinatário.</li><li>E então a agência de correios cuidará de entregar sua carta.</li></ol><p>Então, como sua carta será enviada e quando ela chegará você já não tem mais conhecimento sobre, você já fez seu trabalho e está “livre” para realizar as demais tarefas.</p><p>Dessa forma acontece com <em>messagers brokers</em>, você propaga uma mensagem em um <strong><em>exchange</em></strong>(caixa de correio) e o <strong>messager broker</strong>(agência de correios) enviará baseado em uma lógica do <strong>exchange</strong> para assim chegar no seu <strong>consumer</strong>(destinatário).</p><blockquote>Porque isso é bom ?</blockquote><p>Como dito anteriormente, <strong>resiliência e escalabilidade </strong>é um dos pontos chaves dessa arquitetura, imagine que você utilize uma comunicação via <strong>HTTP</strong>, se você emitir uma request diretamente ao microserviço há alguns problemas no qual você terá de lidar:</p><ol><li><strong>Baixa resiliência</strong> — Enviar uma requisição HTTP, além de <strong>latência, </strong>seu microserviço fica fortemente <strong>acoplado </strong>ao endpoint requerido, fugindo de um dos conceitos chaves dessa arquitetura.</li><li><strong>Baixo escalonamento horizontal — </strong>Normalmente sua requisição será em um cluster interno (assumindo que sua arquitetura faz uso de um <a href="https://docs.aws.amazon.com/apigateway/index.html">API Gateway</a>) e como iria ser feito o load balancer desse evento ? No mínimo será necessário fazer um proxy + load balancer para cada microserviço ou fazer sua requisição passar pelo gateway, a grande pergunta aqui é: <strong>vale todo esse esforço?</strong> Provavelmente <strong>não</strong>.</li></ol><blockquote>E como isso funciona assincronamente?</blockquote><p>Agora vamos supor a mesma situação acima porém de forma assíncrona, e os mesmos problemas relatados serão ajustados:</p><ol><li><strong>Resiliência e Baixo acoplamento</strong> — De fato, ambas palavras são fortes, e <strong>devem </strong>ser buscadas sempre que possível em qualquer aplicação. Como seus eventos serão enviados a um intermediário<strong>(RabbitMQ)</strong> será necessário somente garantir que esse serviço esteja funcionando, e como a messagem será enviada ao microserviço destinatário já não será do domínio da sua aplicação… Portanto, quanto menos souber do destinatário, mais coesa e escalável fica sua arquitetura.</li><li><strong>Escalonamento horizontal</strong> — Com RabbitMQ (<em>e qualquer outra tecnologia de messageria</em>) é feito automaticamente um Load Balancer de suas mensagens, baseado na forma escolhida pelo <strong>exchange, </strong>por <em>default </em>será <strong>Competing Workers Pattern </strong>(explicarei melhor sobre esse padrão abaixo). Enfim, fato é, você consegue escalar sua arquitetura horizontalmente de forma simples e prática.</li></ol><h3>Comunicação Assíncrona</h3><p>A comunicação assíncrona é amplamente usada quando não há necessidade de esperar uma resposta. Porém, há casos na qual ela se aplique, <strong>RPC </strong>é um dos patterns que há uma espera por uma resposta.</p><p>Ao esperarmos uma resposta de qualquer recurso, sua aplicação fica em standby aguardando uma resposta que pode nunca vir (dependendo do timeout, claro!) e, convenhamos…. É um disperdício deixar um hardware aguardar por algo sendo que há tanto processo que poderia ser feito, não?</p><p>Fora isso, há alguns pontos para se levar em conta quando decidir utilizar uma arquitetura assíncrona:</p><ul><li>Baixo desacoplamento — Como mencinamos nos tópicos acima, desacoplamento é algo ótimo, e deixa a aplicação mais flexível.</li><li>Sem dependência de uma client library — Quem nunca teve de criar um SDK para utilizar nos produtos internos que requisitavam o grande monolítico chamado carinhosamente de API? Pois bem, gerenciar versões, e manter isso era um <em>pouco</em> problemático.</li></ul><p>Nesse artigo, tentarei mostrar alguns dos padrões utilizados na messageria assíncrona step by step, e o resultado disso você pode encontrar <a href="https://github.com/RafaelGSS/microservice-communication"><strong>aqui</strong></a><strong>.</strong></p><blockquote>É necessario quem um serviço RabbitMQ esteja rodando, caso não tenha, basta subir esse container:</blockquote><blockquote>docker run -d -p 8080:15672 -p 5672:5672 -p 25676:25676 rabbitmq:3-management</blockquote><h3>Competing Workers Pattern</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sO3z1p1s_-9Nj414.png" /><figcaption>fonte: <a href="https://blog.cdemi.io/design-patterns-competing-consumer-pattern/">https://blog.cdemi.io/design-patterns-competing-consumer-pattern/</a></figcaption></figure><p>Competing Workers Pattern ou Competing Consumers Pattern, é um pattern comumente usado em uma arquitetura de microsserviços, pois ele consiste no load balancer de mensagens de uma fila, entre os <strong>N</strong> consumers. Ou seja, escalar uma aplicação que utiliza deste pattern é muito simples.</p><blockquote>E como isso funciona na prática?</blockquote><p>Certo, então vamos lá! Primeiro de tudo, vamos precisar criar um producer.js que ficará responsável por emitir um evento em um <strong>exchange</strong>. Quando não definimos um exchange, e emitimos o evento diretamente na fila, ele fará o uso de um exchange <strong>default </strong>que será o caso aqui.</p><p>Vamos criar um <em>produtor</em> de eventos, que enviará uma mensagem para a fila nomeada: <em>mensagens </em>a cada segundo.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8f6369ed7d984cba3fdb0ab99ec4dbee/href">https://medium.com/media/8f6369ed7d984cba3fdb0ab99ec4dbee/href</a></iframe><p>E da mesma forma iremos criar nosso consumer.js para consumir as mensagens da fila:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e55e3fa9dd54a34c4b9e1c0a1eaef804/href">https://medium.com/media/e55e3fa9dd54a34c4b9e1c0a1eaef804/href</a></iframe><p>Baseado nos snippets acima, estamos <em>“habilitados”</em> para escalar as mensagens em <strong>N consumers.</strong></p><p>Rodando ambos ao mesmo tempo, teremos algo como:</p><figure><img alt="Exemplo pattern competing consumers" src="https://cdn-images-1.medium.com/max/1024/1*Uty8TrDg-tI2yQr2T1jxyw.gif" /><figcaption>Exemplo de load balancer (competing consumers)</figcaption></figure><p>Perceba que as mensagens são divididas entre os consumers.</p><p>O código desse exemplo está <a href="https://github.com/RafaelGSS/rabbitmq-workflow-example/tree/master/exchange/default"><strong>aqui</strong></a>. Se quiser saber mais sobre esse padrão, <a href="https://www.enterpriseintegrationpatterns.com/patterns/messaging/CompetingConsumers.html"><strong>este</strong></a> é um bom start.</p><h3>Topics Pattern</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/424/1*YAJI3SQ9cInvUop2WJ8qag.png" /></figure><p>Enviar eventos diretamente a uma fila é simples e fácil, porém quando a arquitetura cresce, novos patterns são necessários.</p><p>Imagine que seja necessário emitir um evento para mais de uma fila — “Ah, basta colocar o nome da fila e enviar!” — Infelizmente não é assim que a banda a toca. Definir filas e enviar acaba deixando sua aplicação acoplada! Ideal seria enviar somente para uma “fila” e ela trataria de encaminhar determinado evento para sua respectiva fila/consumer, certo? Pra isso existem os <strong>Topics Pattern</strong>!</p><p>Imagine um cenário aonde é enviado logs da sua aplicação para uma fila qualquer… em um primeiro momento, vai funcionar perfeitamente bem, porém, no futuro imagino que seja necessário aumentar a granularidade desse log e enviar baseado nos níveis de log (debug, warning, critical).</p><blockquote>Quebrar os logs por níveis pode fazer com que aumente a flexibilidade de sua aplicaçao.</blockquote><p>Eventos emitidos para um topic deverá conter um argumento chamado routing_key que deverá ser uma lista de palavras separadas por ponto(.). Exemplo: log.warning ou log.critical . Portanto, um evento enviado ao <em>topic exchange </em>será entregue a todas as filas na qual de “match” com o routing_key passado.</p><p>Imagine que temos 3 filas:</p><ul><li>warning.logs — Responsável por processar alguma regra de negócio quando receber um Warning Log, portanto, seu bind será log.warning.</li><li>critical.logs — Responsável por disparar alertas quando receber um Critial Log, portanto, seu bind será log.critical.</li><li>logs — Responsável por salvar qualquer tipo de log, então seu bind será log.*. O asteristico(*) indica que pode ser substituído por <strong>uma </strong>palavra qualquer.</li></ul><blockquote>Há também o <em># </em>para bind, que pode ser substituído por zero ou mais palavras.</blockquote><p>Segue um exemplo de <strong>dois</strong> consumers(canto direito) e <strong>um </strong>producer(canto esquerdo), onde o consumer1.js(canto superior direito) irá aguardar somente eventos <strong>#.critical.# </strong>e o consumer2.js(canto inferior direito) irá aguardar <strong>todos</strong> eventos</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-3jEu2yZqoT03S1AUmgOHg.gif" /></figure><p>O código desse exemplo está <a href="https://github.com/RafaelGSS/rabbitmq-workflow-example/tree/master/exchange/topic"><strong>aqui</strong></a></p><h3>Fanout Pattern</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/698/1*p-UQwOf6jU977U-f_nRDsA.png" /></figure><p>Topics nos deu uma flexibilidade e tanta. Porém, da forma apresentada, ele continua seguindo o Pattern <em>Competing Workers. </em>E se quiséssemos fazer o broadcast desse evento para várias filas?</p><blockquote>Esse Pattern é muito usado não só com message brokers e sim na arquitetura de microservicos no geral, vale conferir!</blockquote><p>Ao propagar uma mensagem para um <strong>fanout exchange</strong> temos a flexibilidade de escalar uma mensagem sem precisar especificamente criar uma fila pra isso. Isso nos permite lançar um evento no qual será processado por todos consumers que estiverem ouvindo a <em>queue</em> ou <em>exchange.</em></p><p>Tomando como exemplo um e-commerce, ao finalizar uma venda precisamos fazer duas diferente tarefas:</p><ol><li>Processar a venda ao financeiro</li><li>Enviar ao serviço de pagamento</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/533/1*MsvP-4MYEZMPYkOvPf-2Dw.png" /></figure><p>E aqui um exemplo da aplicação rodando, o código fonte dela você pode conferir <a href="https://github.com/RafaelGSS/rabbitmq-workflow-example/tree/master/exchange/fanout"><strong>aqui</strong></a><strong>.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ilNs2Px2cRX6PZjhNHNH0Q.gif" /></figure><h3>RPC Pattern</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/598/1*vkYkMgb7KYl3qZiAVX9SOA.png" /><figcaption>fonte: <a href="http://alvaro-videla.com/2010/10/rpc-over-rabbitmq.html">http://alvaro-videla.com/2010/10/rpc-over-rabbitmq.html</a></figcaption></figure><p>Ao enviar uma mensagem assíncrona, boa parte das vezes enviamos <strong>ações</strong> e não <strong>questões</strong>. Porém, há cenários onde será necessário requisitar algum recurso e “<em>aguardar”</em> por uma resposta; pra isso existe um pattern bastante conhecido chamado <strong>Remote Procedure Call </strong>ou simplesmente <strong>RPC</strong>.</p><p>Vamos imaginar um cenário aonde será necessário requisitar um usuário de um microserviço RPC baseado em seu ID.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PQ9f9TLalzFD9sA4V_qbnQ.png" /></figure><p>Tendo como base a image acima:</p><ul><li>Producer — Serviço de usuário, no qual estará aguardando requisições RPC para assim responde-las.</li><li>Consumer — Serviço no qual tem usuário como dependência, enviará o ID do usuário requisitado para receber o nome do mesmo.</li></ul><p>Veja que o producer recebeu um ID: <em>“[*] Received: 1” </em>e assim, o consumer recebeu o nome do usuário requisitado: “<em>[uuid] Received: Paul Jhon” </em>portanto o processo de <em>request/reply</em> funcionou perfeitamente.</p><p>Bom… Imagino que tenha surgido algumas dúvidas:</p><ul><li>O que é o UUID?</li><li>O que é o replyTo?</li></ul><p>Ao enviar uma <strong>questão</strong> <strong>assíncrona </strong>tambem recebemos uma <strong>resposta assíncrona</strong> e como saber a correlação entre a pergunta número 1 e a resposta número 1? Na comunicação assíncrona dificilmente você conseguirá garantir que as mensagens cheguem em sua ordem natural (1, 2, 3… 99). É nisso que o correlation_id é usado, ele será a ligação entre a pergunta número 1 e a resposta número X.</p><p>Agora, voltando a imagem de exemplo acima, enviamos uma mensagem com o <em>UUID/correlation_id</em> fa6cc6a2-XXXXX-856 e recebemos a resposta contendo o mesmo <em>correlation_id</em>, portando, temos a garantia que esse resposta seja referente a questão acima.</p><blockquote>E o replyTo?</blockquote><p>Bem, ele é o nome da fila no qual será enviada a resposta. Um microserviço que aguarda requisições RPC não deve ter uma fila de respostas, pois as perguntas podem vir de varios outros serviços. Sendo assim, ao receber o parâmetro replyTo ele saberá pra qual fila responder. Um simples callback queue.</p><p>O código desse exemplo você encontra <a href="https://github.com/RafaelGSS/rabbitmq-workflow-example/tree/master/rpc"><strong>aqui</strong></a>.</p><h3>Considerações finais</h3><p>Nesse artigo, tentei abordar de forma mais teórica possível a comunicação entre microsserviços com RabbitMQ, mas caso sinta falta de linhas de código, eu criei um repositório com todos os code examples que utilizarei nessa série. Basta clicar <a href="https://github.com/RafaelGSS/microservice-communication"><strong>aqui</strong></a>.</p><p>Lembrando… a documentação do RabbitMQ é excelente e super simples! Vale conferir.</p><p>Redes sociais: <a href="https://github.com/rafaelgss"><strong>Github</strong></a><strong>, </strong><a href="https://twitter.com/_rafaelgss"><strong>Twitter</strong></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed3e5897ba6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fastify, Porque outro framework JS?]]></title>
            <link>https://medium.com/@rafaelgss/fastify-porque-outro-framework-js-5d7360ba4aa6?source=rss-b09ac8eb5393------2</link>
            <guid isPermaLink="false">https://medium.com/p/5d7360ba4aa6</guid>
            <category><![CDATA[javascri]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[fastify]]></category>
            <category><![CDATA[nodejs]]></category>
            <category><![CDATA[framework]]></category>
            <dc:creator><![CDATA[Rafael Gonzaga]]></dc:creator>
            <pubDate>Fri, 26 Jul 2019 16:49:11 GMT</pubDate>
            <atom:updated>2022-01-28T04:03:36.923Z</atom:updated>
            <content:encoded><![CDATA[<h3>Fastify, Por que outro framework JS?</h3><p>Uma introdução aos conceitos e motivações por trás do framework.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*my2MwgjbxHWLU45c.png" /><figcaption>Fastify brand image</figcaption></figure><p>Todos sabemos que o ecossistema Javascript é formado por diversos frameworks (<em>possivelmente enquanto você está lendo esse artigo, um novo framework js é criado</em>). E neste artigo irei apresentar um framework chamado <strong>Fastify</strong>, e o porque ele chamou minha atenção.</p><p><strong>👋 Me siga no </strong><a href="https://twitter.com/_rafaelgss"><strong>Twitter</strong></a><strong>!</strong></p><p><a href="https://github.com/fastify/fastify"><strong>Fastify</strong></a><strong> </strong>é um framework web para Node.js com foco em <strong>performance </strong>e <strong>baixo </strong><a href="https://en.wikipedia.org/wiki/Overhead_(computing)"><strong>overhead</strong></a>, sendo assim uma ótima escolha pra você que está desenvolvendo uma arquitetura baseada em <a href="https://en.wikipedia.org/wiki/Microservices">microservices</a>.</p><p>Estamos trabalhando bastante para deixar a <a href="https://github.com/fastify/fastify#documentation">documentação</a> ainda melhor… Portanto, se encontrar algum erro, mande um PR. 😁</p><p>E ah… uns de seus patrocinadores é a empresa: <a href="https://medium.com/u/4d2ed76cb5eb">NearForm</a>.</p><h3>Benchmarks</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/654/1*O9vo3b_G0gf8PM1xpaZl0w.png" /><figcaption>Gráfico de Benchmark — Testes feitos com Node 8.4 — <a href="https://www.nearform.com/blog/reaching-ludicrous-speed-with-fastify/">referência</a></figcaption></figure><p>Aqui comparando o<em> http-router</em> de alguns frameworks:</p><ul><li>find-my-way —<strong> (Fastify)</strong></li><li><a href="https://github.com/yahoo/routr">routr</a> — (<strong>Yahoo INC</strong>)</li><li>koa-router — (<strong>Koa</strong>)</li><li>express — (<strong>Express</strong>)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/846/1*8Ist58BSMOFPHnl-VPYsAA.png" /><figcaption>Comparação entre http-router — <a href="https://www.nearform.com/blog/reaching-ludicrous-speed-with-fastify/">referência</a></figcaption></figure><p>Isso porque <a href="https://github.com/delvedor/find-my-way"><strong>find-my-way</strong></a><strong> </strong>usa um algoritmo chamado <a href="https://en.wikipedia.org/wiki/Radix_tree"><em>radix tree</em></a><em> </em>internamente para realizar o roteamento, isso é um fator excepcional de performance comparado aos outros <em>http-routes. </em>Vou deixar pra falar sobre o algoritmo em si, em um post futuro.</p><p>Você pode conferir mais sobre benchmarks <a href="https://www.fastify.io/benchmarks/">aqui</a>, e <a href="https://www.nearform.com/blog/reaching-ludicrous-speed-with-fastify/">nesse</a> post sensacional.</p><h3>No Fastify, tudo é um plugin!</h3><p>Isso mesmo! Suas rotas, seus utilitários, tudo é um plugin! Fastify utiliza um incrível design para evitar um alto acoplamento, e assim fazer o <strong>bootstrap assíncrono </strong>dos plugins. Graças ao <a href="https://github.com/mcollina/avvio">Avvio</a>, amém!</p><p>Bom… vamos codar!</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FyoJC2COHSxjIqadyZW%2Ftwitter%2Fiframe&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2Flastweektonight-hbo-john-oliver-last-week-tonight-yoJC2COHSxjIqadyZW&amp;image=https%3A%2F%2Fmedia.giphy.com%2Fmedia%2FyoJC2COHSxjIqadyZW%2Fgiphy.gif&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="244" frameborder="0" scrolling="no"><a href="https://medium.com/media/776981f02193afcf70f710d0e1059d00/href">https://medium.com/media/776981f02193afcf70f710d0e1059d00/href</a></iframe><p>Primeiro de tudo, vamos instalar o Fastify:</p><pre>npm i -S fastify</pre><p>E agora vamos criar nosso index.js juntamente com nossos plugins:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5cd21396de9cc5539b374946c177b8e3/href">https://medium.com/media/5cd21396de9cc5539b374946c177b8e3/href</a></iframe><p>Como você podem ver nesse snippet index.js acima:</p><p><strong>Linha 1</strong> — Instanciamos o Fastify.<br><strong>Linha 3 </strong>— Criamos um <a href="https://github.com/fastify/fastify/blob/master/docs/Decorators.md"><strong>Decorator</strong></a>(mais sobre ele abaixo) e adicionamos uma propriedade chamada: <em>configuration.<br></em><strong>Linha 8 </strong>— Registramos o plugin1.js.<br><strong>Linha 10 </strong>- Registramos o plugin2.js.<br><strong>Linha 12 </strong>- Inicializamos o http-router do Fastify para aceitar conexões HTTP na porta 3000.</p><p>E agora nossos plugins:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0fecc88d3b4a4797bf1d50b7cf9da576/href">https://medium.com/media/0fecc88d3b4a4797bf1d50b7cf9da576/href</a></iframe><p>Nos plugins, recebemos o contexto atual (instância Fastify) para podermos trabalhar a partir deste escopo.</p><p>O Fastify provê uma API no qual consta com diversas funcionalidades, dentre elas (usadas no código acima):</p><p><strong>Register — </strong>O Fastify cria<strong> </strong>um<strong> novo scopo</strong> encapsulando seu plugin. No qual receberá como injeção de dependência:</p><ol><li><em>fastify — </em>Instância fastify no contexto atual.</li><li><em>opts</em> — opções passadas pelo Register</li><li><em>next</em> — Assim como qualquer handler no Express.</li></ol><p><strong>Decorate</strong> — Tem o poder de definir um atributo a <strong>instância atual </strong>do Fastify. Por isso o encapsulamento, as mudanças não se propagarão para seus ancestrais, somente para seus filhos! Essa feature nos permite obter herança de plugins junto ao encapsulamento, e desse modo, podemos criar um gráfico acíclico direto (<a href="https://en.wikipedia.org/wiki/Directed_acyclic_graph">DAG</a>).</p><blockquote>Perceba que, no plugin2.js e na linha 5, ele printou <strong>undefined</strong> porque aquele contexto passado ao plugin, não contém aquela propriedade. Encapsulamento!</blockquote><blockquote>— “Mas e se eu usar adicionar uma propriedade no mesmo contexto?” — O Fastify provê um plugin pra isso: <a href="https://www.npmjs.com/package/fastify-plugin"><em>fastify-plugin</em></a><em>.</em></blockquote><h3>Porque encapsulamento é tão importante ?!</h3><p>Fastify devido ao seu modelo de encapsulação evita dependências cruzadas (<a href="https://en.wikipedia.org/wiki/Separation_of_concerns">Separation of Concerns</a>). Portanto, facilita a manutenção/depuração da sua aplicação.</p><p>Seguindo esse modelo, podemos quebrar nossa aplicação em vários microserviços a qualquer momento sem precisar refatorar todo seu projeto.</p><h3>Validação de Schema ?</h3><p>Validar os parâmetros da requisição e ainda documentar parece bom né?!</p><p>O Fastify por padrão faz uso do <a href="https://github.com/epoberezkin/ajv">Ajv</a> para validação de parâmetros, e junto ao plugin <a href="https://github.com/fastify/fastify-swagger">fastify-swagger</a> você documenta enquanto valida os dados.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fgiphy.com%2Fembed%2FSJX3gbZ2dbaEhU92Pu%2Ftwitter%2Fiframe&amp;display_name=Giphy&amp;url=https%3A%2F%2Fgiphy.com%2Fgifs%2Freaction-mood-SJX3gbZ2dbaEhU92Pu&amp;image=https%3A%2F%2Fmedia2.giphy.com%2Fmedia%2FSJX3gbZ2dbaEhU92Pu%2Fgiphy.gif&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=giphy" width="435" height="243" frameborder="0" scrolling="no"><a href="https://medium.com/media/623d47fcd337825013d008952fdd8079/href">https://medium.com/media/623d47fcd337825013d008952fdd8079/href</a></iframe><p>Vamos fazer uma API com validação/documentação como exemplo.<br>Primeiro vamos instalar nossas dependências:</p><p>npm i -S fastify-swagger</p><p>E então:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/aea8e965500546aecfed89074f112c80/href">https://medium.com/media/aea8e965500546aecfed89074f112c80/href</a></iframe><p>Esse snippet é simples, somente para mostrar a funcionalidade dos plugins do fastify e sua validação padrão com Ajv (Lembrando, você pode usar o schema compiler que você quiser, <a href="https://github.com/hapijs/joi">Joi</a> é um bom exemplo disso). Então, vamos a descrição da linha mais importante:</p><ul><li><strong>Linha 15:</strong> Nós registramos a rota e adicionamos um schema, e essa estrutura acima nos diz que estamos esperando um paramêtro na query com o nome de <em>anyParam</em> no qual seu tipo é <em>number</em> e esse mesmo campo é obrigatório. Ou seja, na rota <em>’/’</em> esperamos um parâmetro de nome <em>anyParam</em> do tipo numérico.</li></ul><p>Vamos testar! Suba seu servidor — node index.js e vá para a página <em>/docs</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yUibrXHd4preDN8NGhEJ9Q.png" /><figcaption>Exemplo Fastify+Swagger</figcaption></figure><p>Feito! Sua rota já está documentada com o <a href="https://swagger.io/">Swagger</a> e caso queira personalizar mais, leia a <a href="https://github.com/fastify/fastify-swagger">documentação</a>.</p><p>Agora vamos testar a validação sem passar o argumento obrigatório <em>anyParam</em>:</p><p>curl -i -H &quot;Accept: application/json&quot; -H &quot;Content-Type: application/json&quot; -X GET http://localhost:3000/</p><p>E então iremos receber o seguinte retorno:</p><pre>{<br>  &quot;statusCode&quot;:400,<br>  &quot;error&quot;:&quot;Bad Request&quot;,<br>  &quot;message&quot;:&quot;querystring should have required property &#39;anyParam&#39;&quot;<br>}</pre><p>Validou nosso parâmetro obrigatório! Agora vamos manda-lo, porém do tipo ‘string’:</p><p>curl -i -H &quot;Accept: application/json&quot; -H &quot;Content-Type: application/json&quot; -X GET <a href="http://localhost:3000/">http://localhost:3000/</a>?anyParam=stringQualquer</p><p>E recebemos:</p><pre>{<br>  &quot;statusCode&quot;:400,<br>  &quot;error&quot;:&quot;Bad Request&quot;,<br>  &quot;message&quot;:&quot;querystring.anyParam should be number&quot;<br>}</pre><p>Validou o tipo do parâmetro! Agora finalmente, vamos mandar o request certo, e verificar seu retorno:</p><p>curl -i -H &quot;Accept: application/json&quot; -H &quot;Content-Type: application/json&quot; -X GET <a href="http://localhost:3000/">http://localhost:3000/</a>?anyParam=10</p><pre>{&quot;ok&quot;:true}</pre><p>Pronto! Schema validado e documentado!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*LXYBULSDZT9a-aNpxQf1Sg.gif" /></figure><h3>Considerações finais</h3><p>Espero ter alimentado um pouco sua curiosidade sobre o Fastify, e que vocês não sigam o velho <a href="https://www.bbc.com/portuguese/brasil-42243930">comportamento de manada</a>, e use <strong>Express</strong> pra tudo hehehe.</p><p>Alguma dúvida ? Só comentar aqui em baixo 😁</p><p>Redes sociais: <a href="https://github.com/RafaelGSS">Github</a>, <a href="https://twitter.com/_rafaelgss">Twitter</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d7360ba4aa6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>