<?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 Lauan Guermandi on Medium]]></title>
        <description><![CDATA[Stories by Lauan Guermandi on Medium]]></description>
        <link>https://medium.com/@lauanguermandi?source=rss-eae16ff5fe23------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Lri0hPyJ9Pspqpox0MILHw.jpeg</url>
            <title>Stories by Lauan Guermandi on Medium</title>
            <link>https://medium.com/@lauanguermandi?source=rss-eae16ff5fe23------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 16:49:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@lauanguermandi/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[Testes de mutação com .NET 8 e Stryker.NET]]></title>
            <link>https://medium.com/@lauanguermandi/testes-de-muta%C3%A7%C3%A3o-com-net-8-e-stryker-net-3f35e2c23922?source=rss-eae16ff5fe23------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f35e2c23922</guid>
            <category><![CDATA[mutation-testing]]></category>
            <category><![CDATA[dotnet]]></category>
            <dc:creator><![CDATA[Lauan Guermandi]]></dc:creator>
            <pubDate>Sat, 17 Feb 2024 01:09:39 GMT</pubDate>
            <atom:updated>2024-02-20T15:56:03.393Z</atom:updated>
            <content:encoded><![CDATA[<h3>Testes de mutação com .NET 8 e Stryker.NET</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*STmyq9VIQwqSspia.jpg" /></figure><h3>Introdução</h3><p>Os testes automatizados contribuem e muito para a qualidade de uma aplicação, ajudam a identificar problemas e aumentam a confiança na hora de realizar alterações, pois se alterar algo e um teste começar a falhar, você sabe que fez algo de errado.</p><p>Mas para isso os testes precisam ser bem escritos, não adianta ter uma cobertura de 100% sendo que os testes deixam várias brechas para problemas. Se uma regra de negócio muda, o teste referente a ela, na maioria das vezes deveria quebrar, se não quebrar, você realmente esta testando a aplicação de maneira eficaz?</p><p>Como podemos fazer para melhorar a qualidade dos testes escritos?</p><h3><strong>Testes de mutação</strong></h3><p>Testes de mutação são uma técnica de teste de software que envolve a introdução de pequenas alterações (mutações) no código fonte de um programa para avaliar a qualidade dos conjuntos de testes. Essas mutações simulam erros que poderiam ocorrer durante o desenvolvimento do software e permitem avaliar a eficácia dos testes na detecção desses erros.</p><p>Podemos utilizar os testes de mutação para avaliar a qualidade dos testes escritos, identificar os mutantes e assim matá-los, melhorando a qualidade do teste escrito, e eliminando brachas para problemas.</p><p>Vamos criar um exemplo utilizando a biblioteca <strong>Stryker.NET:</strong></p><p>Primeiro criamos uma solução em branco:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/702/1*u63U9OJiRKLw3X1vdKmCaA.png" /></figure><p>Em seguida criamos dois projetos, um projeto utilizando o template <strong>Biblioteca de classes</strong>, e outro para os testes utilizando o template do <strong>xUnit</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/335/1*fKvm6VZvsIYkJIg0qP4qlw.png" /></figure><p>No primeiro projeto vamos adicionar uma class Person, com a seguinte implementação:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7f3bedc0be5127c496090a5697def9be/href">https://medium.com/media/7f3bedc0be5127c496090a5697def9be/href</a></iframe><p>E no projeto de testes vamos criar os seguintes testes:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7d54d9d7b81c613d0b70d31fd09e8f9e/href">https://medium.com/media/7d54d9d7b81c613d0b70d31fd09e8f9e/href</a></iframe><p>e ao executá-los, temos sucesso.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/527/1*cxftUtbDtu_8_lYgFu7niA.png" /></figure><p>Porém os testes criados realmente são efetivos?</p><p>Vamos instalar o Stryker.NET utilizando o seguinte comando:</p><pre>dotnet tool install -g dotnet-stryker</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/905/1*SE9QGBJVX8TkOEARxc1ZPQ.png" /></figure><p>em seguida, na pasta do projeto executamos o seguinte comando para rodar os testes de mutação:</p><pre>dotnet-stryker -l complete</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*80r_s2limYaU9oF2uCM8IA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QGEk1NULUQ9ye9Vg6hjpgg.png" /></figure><p>Ao acessar o caminho do relatório gerado, temos a seguinte visão:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V7CTPNA8ebzlitk5B_Vnug.png" /></figure><p>Então clicamos em Person.cs:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/560/1*pFK5IqVwxCRvbEOzIo9tqA.png" /></figure><p>Podemos visualizar que um mutante sobreviveu!</p><p>O que ocorreu? Alterar a condição <strong>Age ≥ 18 </strong>para <strong>Age &gt; 19</strong>, os testes continuaram funcionando, pois não eram estreitos ao regra de negócio.</p><p>Imagine que por algum motivo alguém altere essa regra por algum motivo, os testes não vão pegar o problema. É por isso que os testes de mutação são importantes.</p><p>Para ficar mais claro vamos melhorar nossa implementação de teste, adicionando um novo caso de teste, utilizando a seguinte linha:</p><pre>    [Theory]<br>    [InlineData(17, false)]<br>    [InlineData(18, true)]<br>    [InlineData(20, true)]<br>    public void ShouldValidatePersonAgeCorrectly(int age, bool isOfLegalPerson)<br>    {<br>        // Arrange<br>        var person = new Person(PersonName, age);<br><br>        // Act &amp; Assert<br>        Assert.Equal(isOfLegalPerson, person.IsOfLegalPerson());<br>    }</pre><p>Incluimos o caso para 18 anos(<strong>[InlineData(18, true)]</strong>), então eliminamos essa brecha no teste, e ao executar o teste de mutação novamente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/553/1*pjACZywQp95uKqftr1r5wg.png" /></figure><p>MATAMOS O MUTANTE!!!</p><h3><strong>Conclusão</strong></h3><p>Em conclusão, os testes de mutação representam uma abordagem crucial para avaliar a eficácia dos testes automatizados. Este artigo demonstrou como a técnica de testes de mutação pode ser aplicada com sucesso em projetos .NET 8 utilizando a biblioteca Stryker.NET. Ao introduzir pequenas alterações no código-fonte e observar como os testes respondem a essas mutações, podemos identificar lacunas na cobertura de teste e garantir que nossos testes sejam mais robustos e eficazes na detecção de erros. Ao integrar testes de mutação em nosso processo de desenvolvimento, podemos elevar significativamente a qualidade do software entregue, aumentando a confiança na estabilidade e no comportamento esperado da aplicação.</p><p><a href="https://github.com/LauanGuermandi/MutationTests-Example">GitHub - LauanGuermandi/MutationTests-Example</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f35e2c23922" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Event-Carried State Transfer: Consistência e isolamento entre microsserviços]]></title>
            <link>https://medium.com/@lauanguermandi/event-carried-state-transfer-consist%C3%AAncia-e-isolamento-entre-microsservi%C3%A7os-89d1937de33d?source=rss-eae16ff5fe23------2</link>
            <guid isPermaLink="false">https://medium.com/p/89d1937de33d</guid>
            <category><![CDATA[bulkhead-pattern]]></category>
            <category><![CDATA[ecst]]></category>
            <category><![CDATA[microservices-pattern]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Lauan Guermandi]]></dc:creator>
            <pubDate>Tue, 13 Feb 2024 01:09:02 GMT</pubDate>
            <atom:updated>2024-02-13T14:32:17.070Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Jy_GU96pWY0GbtD0.jpg" /></figure><h3>Introdução</h3><p>Ao trabalhar com a consistência eventual dos dados, temos desafios importantes para resolver, pois ao perder a consistência, a aplicação não cumpre a regra de negócio proposta.</p><h3>Evento de domínio</h3><p>Um <a href="https://medium.com/@lauanguermandi/microsservi%C3%A7os-eventos-de-dom%C3%ADnio-970829718b9a">evento de domínio</a> reflete mudanças de estado ou a ocorrência de atividades importantes no domínio de negócios específico ao qual o sistema está relacionado.</p><h3>Vamos ao exemplo</h3><p>Imagine que temos os seguintes microsserviços.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*Ty_Lo6mCzEHpl9zuvzdrVA.png" /></figure><p>Ao adicionar um novo pedido e ele ser pago, um evento de domínio <strong>PagamentoEvetuado </strong>é gerado. Para fazer o envio a api de remessa recebe esse evento e prepara o envio, e para isso ela precisa do endereço do cliente que não vem no evento. Como obtemos essa informação?</p><p>Podemos consultar os dados na serviço de cliente da seguinte forma.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/835/1*-iUHzEOORqTcK2AJXe8jqg.png" /></figure><p>Qual problema podemos ter com essa abordagem?</p><p>Se o serviço de cliente estiver fora, não vamos conseguir consultar essas informações assim não vamos conseguir fazer o pedido.</p><blockquote><strong>Bulkhead Pattern</strong></blockquote><blockquote>Basicamente, o padrão Bulkhead propõe a divisão do sistema em “compartimentos” separados, onde cada componente ou serviço é isolado uns dos outros, geralmente utilizando recursos diferentes, como threads, pools de conexão ou até mesmo máquinas separadas. Dessa forma, se um compartimento falhar ou for sobrecarregado, os outros compartimentos podem continuar funcionando normalmente.</blockquote><blockquote>o padrão Bulkhead visa isolar e limitar os danos causados por falhas em uma parte do sistema, impedindo que essas falhas se propaguem para outras partes.</blockquote><p>A nossa solução de fazer a consulta no serviço de cliente, fere esse padrão, pois não temos o isolamento dos serviços, já que o serviço de remessa depende diretamente do serviço de cliente.</p><p>Para isso podemos aplicar o padrão <strong>Event-Carried State Transfer</strong>.</p><h3>Event-Carried State Transfer</h3><p>Esse padrão é um variação do padrão <strong><em>State Transfer</em></strong>. É um padrão arquitetural utilizado em sistemas distribuídos para manter o estado consistente entre diferentes componentes ou serviços e consiste em utilizar um evento para agregar dados a um serviço.</p><p>Para o nosso exemplo, podemos utilizar este padrão para remover a dependência do serviço de remessa ao serviço de cliente, replicando os dados do cliente para sua base de dados a partir dos eventos de domínio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/838/1*17_10hKrh3n7LeJqYkbvvA.png" /></figure><h3>Conslusão</h3><p>Portanto, ao considerar os desafios enfrentados na integração de microsserviços e a necessidade de garantir a resiliência do sistema, é crucial adotar abordagens arquiteturais adequadas. Enquanto o padrão Bulkhead oferece uma estratégia eficaz para isolar e limitar falhas em diferentes partes do sistema, a dependência direta entre serviços pode comprometer esse isolamento. A implementação do padrão Event-Carried State Transfer surge como uma solução promissora para remover essas dependências, permitindo a transferência de dados relevantes por meio de eventos de domínio. Ao adotar essa abordagem, os microsserviços podem operar de forma mais independente e resiliente, contribuindo para a estabilidade e eficiência do sistema como um todo.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=89d1937de33d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microsserviços: Event Sourcing X Transational Outbox]]></title>
            <link>https://medium.com/@lauanguermandi/microsservi%C3%A7os-event-soucing-x-transational-outbox-0f6bdba4faa9?source=rss-eae16ff5fe23------2</link>
            <guid isPermaLink="false">https://medium.com/p/0f6bdba4faa9</guid>
            <category><![CDATA[transational-outbox]]></category>
            <category><![CDATA[event-sourcing]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[microservices-pattern]]></category>
            <dc:creator><![CDATA[Lauan Guermandi]]></dc:creator>
            <pubDate>Fri, 02 Feb 2024 15:06:35 GMT</pubDate>
            <atom:updated>2025-09-09T14:22:43.207Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*i-uFm5zFQiJrzQ0w.jpg" /></figure><h3><strong>Introdução</strong></h3><p>Uma das maiores dificuldades quando trabalhamos com microsserviços, quando se escolhe trabalhar com eventos, é como manipula-los de forma eficiente, e garatir a propagação de sua ocorrência.</p><h3>Event Sourcing</h3><p><strong>Event Sourcing</strong><br> O <em>Event Sourcing</em> oferece uma estratégia diferente da convencional para a persistência de agregados, onde realizamos a persistência dos <strong>eventos que representam as alterações de estado</strong> do agregado.</p><p>Imagine que tenho uma agregação Pedido. Quando adiciono um novo pedido, gero o evento PedidoRealizado. Ao escolher trabalhar com <em>Event Sourcing</em>, devo persistir esse evento, em vez de salvar o agregado diretamente, como ocorre no modelo tradicional de <em>State Source</em>.</p><p>Segue um exemplo básico de como podemos estruturar esse evento:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/af289cad41902fc886198f2dbd61e1b5/href">https://medium.com/media/af289cad41902fc886198f2dbd61e1b5/href</a></iframe><p>Ao realizar a persistência de todos os eventos de domínio, garantimos que todo o <strong>histórico de vida da agregação</strong> esteja registrado. Dessa forma, é possível reconstruir a agregação em cenários de recuperação de desastre.</p><p>Além disso, conseguimos identificar falhas em processos, já que todas as operações realizadas naquela agregação desde a sua criação ficam registradas. Ou seja, todo o ciclo de vida do agregado permanece documentado.</p><p>Também é possível incluir dados adicionais, como informações do usuário que executou a ação, permitindo auditoria completa sobre quem realizou cada operação.</p><p><strong>Memento</strong></p><p>O padrão Memento pode ser um poderoso aliado no contexto do Event Sourcing, pois ele permite que você capture e restaure o estado de um objeto em um ponto específico do tempo. Em sistemas onde o Event Sourcing é utilizado, o Memento pode ser empregado para criar instantâneos do estado de uma agregação em momentos críticos, facilitando a recuperação e otimização da reconstituição do estado.</p><p>Por exemplo, imagine que o estado de um Pedido se desenvolveu ao longo de uma série de eventos ao longo do tempo. Em vez de reprocessar todos os eventos desde o início para recriar o estado atual, o Memento pode ser utilizado para armazenar estados intermediários da agregação. Isso pode ser particularmente útil em situações de recuperação de desastres ou quando a performance é crítica.</p><p>Ao combinar o Memento com Event Sourcing, você pode armazenar mementos em intervalos regulares ou em momentos críticos (como após a criação do Pedido ou antes de uma mudança significativa), e então, durante uma operação de leitura ou reconstrução, aplicar apenas os eventos que ocorreram após o último memento.</p><p>Dessa forma, o Memento adiciona uma camada de eficiência e resiliência ao Event Sourcing, ajudando a balancear a necessidade de histórico completo com a necessidade de desempenho em ambientes críticos.</p><h3>Transational Outbox</h3><p>Imagine após o pedido ser realizado, realizamos a inclusão dele no banco de dados e ao tentar fazer a publicação do evento no serviço de mensageria, ele está indisponível. Isso é um grande problema, pois gera uma inconsistência onde recebi um pedido, mas não atualizei meu estoque reservando o produto.</p><p>O <strong>Transational Outbox</strong> vem pra resolver esse problema. O padrão consite em realizar a persistência da alteração de estado da agregação, e a persistência do <a href="https://medium.com/@lauanguermandi/microsservi%C3%A7os-eventos-de-dom%C3%ADnio-970829718b9a"><strong>evento de domínio</strong></a>, com status de <strong>Pendente </strong>gerado na mesma transação, tornando a operação atômica.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MNEgD4ibV_57-fKBWov_YQ.png" /></figure><p>Após podemos tentar realizar a publicação do evento para o serviço de mensageria, caso ele esteja indisponível, podemos deixar a responsabilidades de realizar as re-tentativas com um componente de propagação de eventos.</p><p>O componente de propagação de eventos, trata-se de uma tarefa agendada, que realiza a busca dos eventos com o status <strong>Pendente</strong>, e realiza a publicação dos mesmos. Após a publicação ter sido efeturada com sucesso, ele atualiza o status do evento para <strong>Publicado</strong>, assim não irá tentar publicá-lo novamente.</p><h3>Conclusão</h3><p>O Transational Outbox pega as melhores coisas do Event Sourcing com o e adiciona um ponto de resiliência. Em aplicações onde a consistência é crítica, acredito ser a opção mais segura, porém também traz uma maior complexidade. Porém se o Memento é necessário o Event Sourcing pode trazer melhores benefícios.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0f6bdba4faa9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microsserviços: Eventos de domínio]]></title>
            <link>https://medium.com/@lauanguermandi/microsservi%C3%A7os-eventos-de-dom%C3%ADnio-970829718b9a?source=rss-eae16ff5fe23------2</link>
            <guid isPermaLink="false">https://medium.com/p/970829718b9a</guid>
            <category><![CDATA[eda]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[domain-events]]></category>
            <dc:creator><![CDATA[Lauan Guermandi]]></dc:creator>
            <pubDate>Tue, 30 Jan 2024 17:23:07 GMT</pubDate>
            <atom:updated>2024-05-03T19:12:44.636Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DRh_afSsCfXrb0ry.jpg" /></figure><h3><strong>Introdução</strong></h3><p>Quando trabalhamos com microsserviços temos diversos desafios, e o padrão de <strong>Evento de Domínio,</strong> na minha opinião, é um padrão inegociavel nesse contexto, já que por escolher a arquitetura de microsserviços, acredito que a aplicação seja realmente complexa.</p><h3>Eventos</h3><p>O que é um evento? Eventos são objetos imutaveis, que representam alterações de estado, ocorridas no passado.</p><h3><strong>Eventos de domínio</strong></h3><p>Um evento de domínio reflete mudanças de estado ou a ocorrência de atividades importantes no domínio de negócios específico ao qual o sistema está relacionado.</p><p>Toda alteração de estado de uma agregação, deve produzir um evento de domínio.</p><p>Caso uma aplicação precise ser informada de quando um ação ocorre, ela pode obter essa informação do evento de domínio correspondente. Esse abordagem garante um baixo acoplamento, pois não há uma dependência direta entre as aplicações.</p><p>No exemplo abaixo, temos uma aplicação que recebe uma pedido, e atualiza o estoque o com base no evento de domínio gerado. A aplicação de estoque pega os produtos e suas quantidades, e utiliza para da baixa no estoque usando esses valores.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/755/1*RFBBLEVgvHP9pbOUw3jz6w.png" /></figure><p>Podemos utilizar esses eventos para manter um histórico das alterações na agregação responsável.</p><h3><strong>Vantagens</strong></h3><p>Conforme suas aplicação ganham maturidade, a utilização deste padrão diminuí fortemente o acoplamento entre aplicações, quando temos uma arquitetura orientada eventos.</p><p>Quando uma aplicação precisa ser responsiva a uma alteração de estado, ela pode simplesmente assinar o tópico.</p><p>Esses dados também pode ir para um DataLake e serem utilizados para análise.</p><p>Exemplo:</p><p><a href="https://app.eventcatalog.dev/overview/">https://app.eventcatalog.dev/overview/</a></p><h3><strong>Conclusão</strong></h3><p>Eventos de domínio são uma ferramenta poderosa para modelar e lidar com mudanças significativas no estado de um sistema, promovendo a comunicação eficaz e facilitando a evolução do software orientado a domínio.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=970829718b9a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microsserviços: API Composition X CQRS para consulta de dados]]></title>
            <link>https://medium.com/@lauanguermandi/microsservi%C3%A7os-api-composition-x-cqrs-para-consulta-de-dados-578932733ac9?source=rss-eae16ff5fe23------2</link>
            <guid isPermaLink="false">https://medium.com/p/578932733ac9</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[cqrs]]></category>
            <category><![CDATA[composition-api]]></category>
            <dc:creator><![CDATA[Lauan Guermandi]]></dc:creator>
            <pubDate>Fri, 26 Jan 2024 13:54:24 GMT</pubDate>
            <atom:updated>2024-04-09T14:04:03.449Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*gOu9KIxb5Bp9Fwpf.jpg" /></figure><h3><strong>Introdução</strong></h3><p>No design típico de microsserviços, o <a href="https://medium.com/@lauanguermandi/microsservi%C3%A7os-arquitetura-de-banco-de-dados-d4d6f2a774a6"><em>padrão Banco de dados por serviço</em></a> indica que cada microsserviço deve ser responsável por seus próprios dados. No entanto, se quisermos acessar dados que outros microsserviços são responsáveis, deveremos ser capazes de encontrar uma solução para isso. Vou apresentar dois padrões como solução para estes problemas.</p><h3>API Composition</h3><p>Esse é o padrão mais simples. Podemos realizar uma consulta que recupere dados de vários serviços, consultando cada serviço por meio de sua API e combinando os resultados.</p><p>Quando temos dados muitas fontes para consultar, API Composition vai ser o melhor padrão.</p><p>Temos o componente agregador dos dados referenciado como <strong>Composer.API</strong> no diagrama abaixo. Ele recebe uma requisição HTTPS pois essa aplicação tem acesso externo, para que o APP frontend, consiga acessá-lo.</p><p>Os demais serviços estão em uma rede interna, onde somente a <strong>Composer.API. </strong>Dessa forma podemos trabalhar com protocólo com melhor performance como HTTP, GRPC, etc.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/813/1*9XlgiVTouFISyidjlrq0-g.png" /></figure><p>Com isso temos algums problemas na escolha deste padrão.</p><p>Realizando as consultas desta forma, temos uma gasto maior de processamento para realizar uma consulta, pois além do processo ter mais etapas, ainda temos que realizar a agregação dos dados em memória.</p><p>Mas o pior problema, é a inconsistência de dados, devido a <strong>Composer.API</strong> realizar a consulta em serviços distintos, pois eles podem retornar dados inconsistentes.</p><h3><strong>Teorema CAP</strong></h3><p><a href="https://medium.com/@lauanguermandi/implementando-cqrs-com-net-6-e-mediatr-c4d080b4ff38"><em>Link</em></a></p><p><strong>Consistência</strong>: É desejável que seus dados sejam consistentes. No CQRS, trabalhamos com a consistência eventual dos dados, já que nem sempre as duas bases de dados(escrita e leitura), estão atualizadas.</p><p><strong>Disponibilidade</strong>: Um dados, por mais que ele não esteja na sua versão mais recente, ele deve ser entregue.</p><p><strong>Tolerância a falhas: </strong>Significa que quando uma parte a sua aplicação parar de funcionar, o resto deve continuar funcionando.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*CM4BKeMjzjA-6lgI6OtC6Q.png" /></figure><p>Dessas opções, você só pode escolher duas, ou seja, se você quer uma aplicação com consistência, e disponibilidade, ela não vai ser tolerante a falhas, e assim segue.</p><p>Ter as 3 opções é impossível.</p><h3><strong>CQRS</strong></h3><p>CQRS singnifica Command-Query Responsability Segregation.</p><p>O padrão consiste em realizarmos a segregação de responsabilidades entre operações de consulta e alteração de estado.</p><p>O padrão pode ser implementado em vários níveis, mas temos melhores resultado a partir do momento que trabalhamos com um banco de dados para escrita e outro para leitura. Nesse modelo, quando realizamos a persistência de novos dados na replica de escrita, provemos uma alteração de estado gerando um evento de domínio, e utilizamos esse evento para atualizar a replica de leitura.</p><p>Normalmente utilizamos um banco NoSQL como replica de leitura, pois temos a opção de salvar os dados da forma desnormalizada , com foco na estrutura que é retornada para o APP.</p><p>Também podemos ter implementações mais simples, somente segregando a lógica de leitura e escrita dentro da aplicação, mas cuidado para não virar um CQS(Command Query Separation), já que você esta removendo possibilidades de design do padrão, que na minha opinião, trazem os melhores benefícios. Se sua implementação se assemelhar a um CQS, talvez compense rever se CQRS faz realmente sentido no seu cenário.</p><p>Um ponto importante, é que um comando não deve retornar dados, pois essa responsabilidade é dos componentes de leitura como diz o padrão, mas nem sempre isso é aplicado. Para resolver esse tipo de problema, você pode enviar identificadores em suas requests, para utiliza-los depois em suas consultas.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/732/1*NLdLuqkNBQtDtgjiwDpSjg.png" /></figure><p>Podemos utilizar o evento de doimínio também, para realizar operações em outros contextos, ou replicar dados em bancos de dados de outros serviços.</p><p>Quando escolhemos o CQRS, temos disponibilidade e tolerância a falhas, assim a nossa consistência é eventual(Teorema CAP).</p><h3><strong>Conslusão</strong></h3><p>CQRS é uma grande opção para minimizar riscos, porém devido a complexidade, exige uma maior maturidade do time. API Composition pode ser utilizado e é bem comum, mas CQRS oferece vantagens técnicas sobre o padrão, caso você não tenha muitas fontes de dados.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=578932733ac9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microsserviços: Arquitetura de banco de dados]]></title>
            <link>https://medium.com/@lauanguermandi/microsservi%C3%A7os-arquitetura-de-banco-de-dados-d4d6f2a774a6?source=rss-eae16ff5fe23------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4d6f2a774a6</guid>
            <category><![CDATA[database-per-service]]></category>
            <category><![CDATA[shared-database]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[databse]]></category>
            <dc:creator><![CDATA[Lauan Guermandi]]></dc:creator>
            <pubDate>Fri, 26 Jan 2024 02:57:49 GMT</pubDate>
            <atom:updated>2024-01-26T03:03:02.845Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*Htu3jJSMupTlvdRB.jpg" /></figure><h3><strong>Introdução</strong></h3><p>Algumas consultas podem incluir dados de vários serviços, por isso é importante saber de estratégias para obtenção desses dados, seja por consulta no serviço, consultando diretamente no banco de dados, propagando um evento de domínio, entre outros estratégias.</p><p>Saber qual estratégia você vai utilizar impacta na arquitetura da sua aplicação.</p><h3><strong>Banco de dados compartilhado</strong></h3><p>Esse padrão consiste em compartilhar o banco de dados em serviços.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/546/1*VH8gWXzrl3FbGbqArb0JCw.png" /></figure><p>Um dos maiores pontos positivos é a facilitação da consulta de atualização de dados. Mas utilizar esse padrão não significa que uma aplicação não pode ter um banco de dados exclusivo, mas sim que as regras do tipo ‘essa aplicação não pode acessar esse banco de dados’ não vão existir.</p><p>Isso parece ótimo a principio, mas utilizar uma banco de dados compartilhado, diminui a resiliência da sua aplicação, tornando o banco de dados um ponto de falha, já que se ele cair, vários fluxos param de funcionar. Também diminui a possibilidade de escalar, já que sua base pode ficar sobrecarregada.</p><p>Esse pontos vão contra os principios dos microsserviços, por isso minha recomendação é não utilizar, embora tenha algumas exceções. E após tomada essa decisão, fica dificil separar futuramente caso haja a necessidade.</p><h3><strong>Banco de dados por serviço</strong></h3><p>Esse padrão consiste em que cada serviço tenha seu próprio banco de dados e vide regra, não possa acessar bancos de dados de outros serviços.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/674/1*rpRcSFzXvm5tvN8qMvkfeg.png" /></figure><p>Esse padrão é o mais recomendado, na minha opinião, pois temos maior resiliência, se um banco para, somente aquele fluxo valor estára com problema.</p><p>Fica mais facil de escalar, pois já que cada serviço acessa um único banco de dados, ele fica menos sobrecarregado, então você escala somente a aplicação de forma automática.</p><p>Também o acomplamento se torna menor, pois um único serviço é responsável por gerir seus dados.</p><p>Uma das questões complicadas de trabalhar dessa forma, é como acessar dados de outros serviços.</p><p>Quando você pode trabalhar com consistência eventual destes dados, recomento que seja gerado um evento de domínio quando houver uma alteração de estado, e utilizar para replicar esse dados, em outros bancos dados. Mas caso a consistência eventual seja um problema, você possivelmente terá que consultar as informações chamando a API proprietária dos dados.</p><h3><strong>Conclusão</strong></h3><p>Utilizar o padrão de <strong>Banco de dados por serviço </strong>é a melhor opção, pois vai de acordo com os beneficios que a arquitetura de microsserviços oferece.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d4d6f2a774a6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Microsserviços: Padrões de decomposição]]></title>
            <link>https://medium.com/@lauanguermandi/microsservi%C3%A7os-padr%C3%B5es-de-decomposi%C3%A7%C3%A3o-2a6698a313c7?source=rss-eae16ff5fe23------2</link>
            <guid isPermaLink="false">https://medium.com/p/2a6698a313c7</guid>
            <category><![CDATA[decomposition]]></category>
            <category><![CDATA[eventstorming]]></category>
            <category><![CDATA[ddd]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Lauan Guermandi]]></dc:creator>
            <pubDate>Thu, 25 Jan 2024 19:51:40 GMT</pubDate>
            <atom:updated>2025-05-21T15:52:53.301Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zrD2S-Numji3l0T6.jpg" /></figure><h3><strong>Introdução</strong></h3><p>Como decompor uma aplicação em serviços? Julgo que atualmente temos 2 principais maneiras de realizar a decomposição de microsserviços, e iremos explicar as duas neste artigo.</p><p>Vamos utilizar como base a funcionalidade de venda de um produto em um <em>e-commerce.</em></p><h3>Event Storming</h3><p>Muitas vezes temos dificuldade ao encontrar os limites entre domínios, subdomínios e bounded contexts.</p><p>O Event Storming é um workshop criado por Alberto Brandolini. Ele visa facilitar a visualização de subdomínios e bounded contexts, além de auxiliar no processo de estabelecimento da linguagem ubíqua.</p><p>Vamos considerar o seguinte fluxo, para aplicar esta técnica.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/977/1*0faTPMeiatDqkHUtK_RhZw.png" /></figure><p>Primeiro levantamos todos os eventos que serão gerados neste fluxo.</p><p>Um evento é algo imutável, que aconteceu no passado. Ele parte de uma alteração de estado. Exemplo: No momento em que realizar a inclusão do pedido, temos um evento gerado, chamado ‘<strong>Pedido Realizado’</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/1*QCA8t1T58SeQx-z9XdYWsg.png" /></figure><p>Dado isso podemos estabelecer um design inicial desse fluxo nos componentes.</p><h3><strong><em>Definindo limites</em></strong></h3><p><em>Como visualizamos os limites de um contexto? O maior sinal, é a mudança da linguagem ubíqua.</em></p><p><em>Exemplo: Primeiro incluímos o </em><strong><em>Pedido, </em></strong><em>depois realizamos o </em><strong><em>Pagamento.</em></strong></p><p><em>Na primeira parte da frase estamos falando da entidade Pedido, e como ela irá sofrer uma alteração de estado, em seguida mudamos nosso contexto para falar de pagamento.</em></p><h3><strong>Decomposição por subdomínio</strong></h3><p>O que é um subdomínio? O DDD implica na decomposição de um domínio em vários subdomínios, assim conseguimos separar o que de fato gera valor e retorno financeiro para a companhia, e assim, estrategicamente podemos colocar nossos maiores esforços nessa parte do Domínio.</p><p>A partir da definição dos contextos delimitados no nosso fluxo, podemos encaixar cada habilidade em seu contexto, a partir da agregação/entidade que ela manipula.</p><p>Exemplo: <strong>Incluir pedido</strong></p><p>Ao realizar a inclusão de uma pedido temos a alteração de estado na entidade <strong>Pedido, </strong>gerando um evento ‘<strong>Pedido Realizado’</strong>. O Contexto responsável por esse pedido é o <strong>Pedido Context, </strong>onde podemos ter uma API de Pedidos, que será responsável por essa habilidade.</p><p>Seguindo esse modelo, podemos decompor toda a solução em serviços.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6dpvOaD5twjZkPPn6SnfuA.png" /></figure><h3>Decomposição por capacidade de negócio</h3><p>O que é uma capacidade de negócio? Uma capacidade de negócios é a capacidade de uma organização de atingir um resultado ou objetivo específico. É uma combinação de pessoas, processos e tecnologia que uma organização precisa para executar uma tarefa ou função. As capacidades de negócios são os alicerces da estratégia de uma organização e são essenciais para atingir seus objetivos.</p><p>O objetivo do nosso fluxo de exemplo é realizar a venda de um produto.</p><p>A partir no desenho do nosso fluxo, componentes e entidades, podemos rastrear varias capacidades, identificando qual ação gera um alteração de estado.</p><p>Exemplo: <strong>Incluir pedido</strong></p><p>As ações que geram alterações de estado na entidade pedido, são a ‘Incluir Pedido’ e ‘Cancelar Pedido’. A partir disso podemos assimilar que precisamos de uma capacidade de ‘<strong>Gerenciamento de pedido</strong>’ ou <strong>‘Order Management’</strong>.</p><p>Abaixo temos o resultado do fluxo completo, em que cada cor de círculo significa uma capacidade.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0ksJwuFYChBLF0irqLn6eQ.png" /></figure><h3><strong>Conclusão</strong></h3><p>Como podem ver os resultado são similares, afinal estamos falando de padrões de decomposição, é natural termos um resultado parecido, pois o objetivo é o mesmo.</p><p>As duas estratégias são ótimas opções, para decidir, acredito que o melhor é levar em consideração seu conhecimento sobre o negócio, e sobre DDD(Domain-Driven Desing).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2a6698a313c7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como publicar um aplicação .NET 6 no Kubernetes, utilizando Azure Devops e Argo CD]]></title>
            <link>https://medium.com/@lauanguermandi/como-publicar-um-aplica%C3%A7%C3%A3o-net-6-no-kubernetes-utilizando-azure-devops-e-argo-cd-cc6382ac0ad4?source=rss-eae16ff5fe23------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc6382ac0ad4</guid>
            <category><![CDATA[gitops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[argo-cd]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[azure-kubernetes-service]]></category>
            <dc:creator><![CDATA[Lauan Guermandi]]></dc:creator>
            <pubDate>Sun, 24 Jul 2022 18:05:35 GMT</pubDate>
            <atom:updated>2022-07-30T01:23:51.343Z</atom:updated>
            <content:encoded><![CDATA[<h3>Como publicar um aplicação .NET 6 no Kubernetes, utilizando Azure Devops e Argo CD</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/1*MfWM245JAkQClYgSiZfZdg.png" /></figure><p><strong>Introdução</strong></p><p>O Docker fornece um ambiente padronizado e estável para nossa aplicação, assim como ajuda a reduzir os problemas com a escalabilidade da aplicação.</p><p>Para orquestrar estes containers temos algumas opções, e neste arquivo iremos utilizar o que talvez seja o mais famoso, o Kubernetes. O Kubernetes é um poderoso orquestrador que containers <em>open source</em>, atualmente mantido pela Cloud Native Computing Fundation, mas que também podemos utiliza-lo em suas versões <em>PaaS</em>, como o AKS da Azure ou o EKS da AWS.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/1*3YT4gzH_QFExfs-NDwTpNA.png" /></figure><p>Como primeiro passo vamos configurar a integração continua, utilizando o Azure Devops, onde teremos um repositório referente ao código da aplicação, que será utilizado para criar e publicar uma imagem do docker, através do azure pipelines.</p><p><strong>Criando o projeto para publicação</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/647/1*6dWD2Ctvs0fxqAcK79vQNQ.png" /></figure><pre>dotnet new sln -n MyApp<br>mkdir src<br>dotnet new webapi -o .\src\MyApp.Api<br>dotnet sln add .\src\MyApp.Api\</pre><p>Para que o Kubernetes verificar a integridade do container executado, será necessário configurarmos um <em>endpoint </em>de Health Check na aplicação. Para isso vamos instalar o <strong>AspNetCore.HealthChecks</strong> no projeto, e adicionar o seguinte código no <strong>Program.cs</strong> da aplicação:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/88539fde215f55859131a4bf0376bd67/href">https://medium.com/media/88539fde215f55859131a4bf0376bd67/href</a></iframe><p>e ao executar, e acessar o path <strong><em>/healthz</em></strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/373/1*loPe5WsLhkKJZhb0gkHutg.png" /></figure><p>Agora criamos um repositório, e enviamos o código com os seguintes comandos:</p><pre>dotnet new gitignore<br>git init<br>git add .<br>git commit -m &quot;feat: add health check&quot;<br>git remote add origin [INSERIR LINK DO REPOSITÓRIO]<br>git push origin master</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1tO35tKgKPVOUk58LpvvZg.png" /></figure><p>Agora que temos nosso repositório, podemos criar nossa pipeline que irá publicar a imagem docker da aplicação.</p><p>Primeiro adicionado um Dockerfile no projeto com o seguinte conteúdo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/93329b9bc47bde1a6bd2f8e0c5c13445/href">https://medium.com/media/93329b9bc47bde1a6bd2f8e0c5c13445/href</a></iframe><p>E também criamos um arquivo GitVersion.yml na raiz do projeto, para nos ajudar com a criação de tags para as imagens.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8592d188a9b3a27d9f306f1abeb0ed8d/href">https://medium.com/media/8592d188a9b3a27d9f306f1abeb0ed8d/href</a></iframe><p>Agora criamos uma pipeline YAML, e adicionamos o seguinte conteúdo:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/c83f489afcefbbc95dc7e1e243f87a73/href">https://medium.com/media/c83f489afcefbbc95dc7e1e243f87a73/href</a></iframe><p>Então executamos a pipelines:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/371/1*-N5Nod0mJDzfQqZIOzUxCg.png" /></figure><p>Ao terminar a execução, podemos visualizar nossa imagem no container registry:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/333/1*WAD0XFlhTFy2CX5UCmpPKQ.png" /></figure><p>Então criamos um Helm Chart na raiz do repositório, utilizando o seguinte comando:</p><pre>helm create chart</pre><p>E alteramos o arquivo <strong>chart/templates/deployment.yml</strong>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ed9ef6b47a96ed0d94beb1dde6bf4193/href">https://medium.com/media/ed9ef6b47a96ed0d94beb1dde6bf4193/href</a></iframe><p>Foram alteradas as linha 42 e 46, para que o path aponte para o nosso endpoint de health check.</p><p>E no arquivo values.yml, vamos adicionar a referencia a imagem publicada no nosso container registry, e realizar o commit:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/504/1*xC2S7vKLWt7BV4fl2KkVAw.png" /></figure><p><strong>Publicando a aplicação</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/1*dRVgZPmlP7uGqBlG8KTcUw.png" /></figure><p><strong>GitOps</strong> é a possibilidade de utilizar todo o código que você produziu para configurar e automatizar a criação dos seus ambientes num repositório Git.</p><p>Para realizar o deploy da nossa aplicação, vamos utilizar o Argo CD. Ele atualiza o ambiente conforme são feitas alterações no seu repositório.</p><p>Iremos utilizar o AKS como plataforma para o nosso Kubernetes. Para instalar o Argo CD, vamos utilizar o seguinte comando:</p><pre>helm repo add bitnami https://charts.bitnami.com/bitnami<br>helm install argo-cd bitnami/argo-cd -set=helm repo add bitnami https://charts.bitnami.com/bitnami<br>helm install argo-cd bitnami/argo-cd --set server.extraArgs=--insecure</pre><p>Para configurar o Argo CD, primeiro vamos adicionar o repositório, clicando no ícone de engrenagem:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/57/1*z2FA1sDPTQzi92U_IyE15g.png" /></figure><p>Depois clique em <strong>CONNECT REPO USING HTTPS</strong>, e adicione os dados do seu repositório:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/670/1*-XpPKaExrrExAfgIP9_aDw.png" /></figure><p>Agora voltamos para a home do Argo CD, e clicamos em <strong>NEW APP</strong>, e inserimos os dados do projeto.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DVf9qN3mJz-T5KSYzHghXg.png" /></figure><p>Também devemos adicionar a referencia ao repositório, e ao cluster Kubernetes neste formulário.</p><p>Após clicar em CREATE, a aplicação é adicionada no Argo CD, e já publicada no Kubernetes.</p><p>E clicando na aplicação podemos visualizar toda a estrutura criada:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NtWIM2fVSpdKdNmv88pteQ.png" /></figure><p><strong>Repositório</strong></p><p><a href="https://github.com/LauanGuermandi/DotNetApp-ArgoCD">GitHub - LauanGuermandi/DotNetApp-ArgoCD: Código referente ao artigo https://medium.com/@lauanguermandi/como-publicar-um-aplica%C3%A7%C3%A3o-net-6-no-kubernetes-utilizando-azure-devops-e-argo-cd-cc6382ac0ad4</a></p><p>Fim. :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc6382ac0ad4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando CQRS com .NET 6 e MediatR]]></title>
            <link>https://medium.com/@lauanguermandi/implementando-cqrs-com-net-6-e-mediatr-c4d080b4ff38?source=rss-eae16ff5fe23------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4d080b4ff38</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[cqrs]]></category>
            <category><![CDATA[arquitetura-de-software]]></category>
            <dc:creator><![CDATA[Lauan Guermandi]]></dc:creator>
            <pubDate>Tue, 31 May 2022 01:35:52 GMT</pubDate>
            <atom:updated>2022-05-31T01:35:52.104Z</atom:updated>
            <content:encoded><![CDATA[<h3>Implementando CQRS com .NET 6 e MediatR</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ELaSiLMgzbGy1sj5.png" /></figure><p><strong>Introdução</strong></p><p>CQRS é um padrão arquitetural com foco em separar leitura a da escrita, onde alterações de dados são realizadas pelos <em>Commands</em>, e leitura de dados são realizadas pelas <em>Queries</em>.</p><p>Quando se utiliza CQRS, temos que ter ciência de que iremos trabalhar com a consistência eventual de nossos dados, já que iremos possuir uma base de dados para leitura e outra para escrita. Eventualmente as duas bases de dados estarão dessincronizadas.</p><p><strong>Command e Query Stack</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6wwHXQWiGT8yw4ZQOunP4w.png" /></figure><p>Como podemos ver no diagrama anterior, a partir de uma interação com o usuário, é gerado um <em>command</em>. Esse <em>command </em>provoca uma alteração no estado de nossa base de dados de <strong>escrita</strong>, e então gera um e<em>vent</em>. A response e recebida pela UI, e de forma assíncrona, o nosso <em>event </em>é processado, atualizando os dados de nossa base de leitura. Então podemos utilizar <em>queries </em>para consulta de dados na base de <strong>leitura</strong>.</p><p><strong>Teorema CAP</strong></p><p><strong>Consistência</strong>: É desejável que seus dados sejam consistentes. No CQRS, trabalhamos com a consistência eventual dos dados, já que nem sempre as duas bases de dados(escrita e leitura), estão atualizadas.</p><p><strong>Disponibilidade</strong>: Um dados, por mais que ele não esteja na sua versão mais recente, ele deve ser entregue.</p><p><strong>Tolerância a falhas: </strong>Significa que quando uma parte a sua aplicação parar de funcionar, o resto deve continuar funcionando.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/555/0*yIEy-9vPLdnPwtBM.png" /></figure><p>Dessas opções, você só pode escolher duas, ou seja, se você quer uma aplicação com consistência, e disponibilidade, ela não vai ser tolerante a falhas, e assim segue.</p><p>Ter as 3 opções é impossível.</p><p>Quando escolhemos o CQRS, temos disponibilidade e tolerância a falhas, assim a nossa consistência é eventual.</p><p><strong>Preparando aplicação</strong></p><p>Primeiro vamos subir um banco SQL Server utilizando o seguinte docker-compose:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8f351831bf33e47e93bc6f1e58749519/href">https://medium.com/media/8f351831bf33e47e93bc6f1e58749519/href</a></iframe><p>E executando o comando:</p><pre>docker-compose up -d</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/312/1*NNEzDqfGiH_38FS84QyWUQ.png" /></figure><p>Agora vamos criar um projeto com o template de <em>webapi:</em></p><pre>dotnet new sln -n Products<br>dotnet new webapi -n Products.Api<br>dotnet sln add .\Products.Api</pre><p>Pronto. O primeiro passo da implementação se definir as entidades e criar contextos de escrita e leitura.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/347/1*E15FWqp35cpgGBB8F6NBVQ.png" /></figure><p>Vamos trabalhar com uma entidade produto para este exemplo.</p><p>Agora criamos nossos contextos.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/541a5b5b4754c36c317ba88f5ded853a/href">https://medium.com/media/541a5b5b4754c36c317ba88f5ded853a/href</a></iframe><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/593fb0387d96dd55f62923fa505736de/href">https://medium.com/media/593fb0387d96dd55f62923fa505736de/href</a></iframe><p>Então configuramos nossas strings de conexão:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U0NwGwSa-6ZHKrQmZ5d4Sg.png" /></figure><p>E utilizando os seguintes comandos, iremos gerar nossa estrutura de banco de dados:</p><pre>dotnet ef migrations add InitialMigration --context ProductWriteContext</pre><pre>dotnet ef migrations add InitialMigration --context ProductReadContext</pre><pre>dotnet ef database update --context ProductWriteContext<br>dotnet ef database update --context ProductReadContext</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aIMRqldKsNtho72k5afmPg.png" /></figure><p>Com nossa estrutura definida, vamos criar uma repositório para realizar as operações no banco de dados:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4d448452cf35d28b7a20a6fd23cb8a8c/href">https://medium.com/media/4d448452cf35d28b7a20a6fd23cb8a8c/href</a></iframe><p>E sua configuração:</p><pre>builder.Services.AddScoped&lt;IProductRepository, ProductRepository&gt;();</pre><p>Com nossa estrutura preparada, já podemos começar a implementação referente ao CQRS.</p><p><strong>Implementando CQRS</strong></p><p>Vamos criar um <em>command </em>que irá adicionar um produto.</p><p>Primeiro criamos o modelo de dados que o <em>command </em>irá receber:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/97d2e999da9a49f8f26adc1a6da2d052/href">https://medium.com/media/97d2e999da9a49f8f26adc1a6da2d052/href</a></iframe><p>E o seu executor(<em>handler</em>):</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/abfa32fff7d1fa86cead03a77987cd1f/href">https://medium.com/media/abfa32fff7d1fa86cead03a77987cd1f/href</a></iframe><p>O modelo deve implementar a interface <strong>IRequest</strong>, com o tipo de retorno do <em>command</em>, que é <strong>bool.</strong></p><p>O executor deve implementar a interface <strong>IRequestHandler</strong>, com o tipo do <em>command</em>, que é <strong>AddProductCommand</strong>, e o tipo de retorno que é <strong>bool</strong>.</p><p>Para configurar a referência do <em>command </em>ao seu <em>handler</em>, utilizamos a seguinte linha:</p><pre>builder.Services.AddMediatR(typeof(<strong>AddProductCommand</strong>).GetTypeInfo().Assembly);</pre><p>E para operações de consulta, vamos criar nosso serviço de <em>queries</em>:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/595e37f8cfa7e61a7a9371afa3ae86a2/href">https://medium.com/media/595e37f8cfa7e61a7a9371afa3ae86a2/href</a></iframe><p>Pronto! Agora vamos criar um <em>controller </em>para executar nossas operações:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/aa13640dd421fa28df7deff1a6e0da1a/href">https://medium.com/media/aa13640dd421fa28df7deff1a6e0da1a/href</a></iframe><p>Agora vamos testar:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ev6WwHK7DF9o-Ts6D0XupA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WjP9jx-aMDkSIEQyiIwpNA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zdUS0hEwnLqVCivY33Ga5w.png" /></figure><p><strong>Repositório</strong></p><p><a href="https://github.com/LauanGuermandi/DotNET-CQRS-MediatR">GitHub - LauanGuermandi/DotNET-CQRS-MediatR</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4d080b4ff38" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Replicando dados de um banco SQL Server para um MongoDB em tempo real com Debezium e Kafka]]></title>
            <link>https://medium.com/@lauanguermandi/replicando-dados-de-um-banco-sql-server-para-um-mongodb-com-debezium-e-kafka-1d33e1fe2131?source=rss-eae16ff5fe23------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d33e1fe2131</guid>
            <category><![CDATA[mongodb]]></category>
            <category><![CDATA[kafka-connect]]></category>
            <category><![CDATA[debezium]]></category>
            <category><![CDATA[sql-server]]></category>
            <category><![CDATA[kafka]]></category>
            <dc:creator><![CDATA[Lauan Guermandi]]></dc:creator>
            <pubDate>Mon, 11 Apr 2022 21:55:40 GMT</pubDate>
            <atom:updated>2022-04-12T13:04:25.976Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/771/1*x57BPeg-EcDvavhNz1OVQQ.png" /></figure><p><strong>Introdução</strong></p><p>Replicar dados de uma banco para outro, pode ser um recurso muito útil para eliminar possíveis cargas desnecessárias em seu banco de dados.</p><p>Vamos imaginar uma cenário onde eu tenho grandes quantidades de dados extraídas, e sendo inseridas em um banco de dados de uma aplicação, o que pode causar lentidão, e até erros devido a <em>timeouts.</em></p><p>Para solucionar este problema podemos distribuir a carga entre bancos. Neste exemplo iremos utilizar o SQL Server e MongoDB.</p><p>Quando um dado for inserido no banco de dados SQL Server, o Debezium lê estes dados do log de alteração do banco, este processo chama-se CDC(Change Data Capture). Então o Connector do Debezium no Kafka Connect pega estes dados e envia para um fila no Kafka. O Connector do MongoDB lê estes dados da fila no Kafka e adiciona ao MongoDB.</p><p><strong>Preparando o ambiente</strong></p><p>Vamos criar nosso ambiente utilizando <em>containers </em>docker. Primeiro vamos criar um <strong>Dockerfile </strong>para nosso container contento o connector do MongoDB.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J0HXQUqGbOfgDKCF_y4NUg.png" /></figure><p>Então utilizamos o seguinte arquivo <strong>docker-compose.yml</strong> para criar nosso ambiente completo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zm7A9PQy0Zc9qNDamf2jkQ.png" /></figure><p>Para executar utilizamos o comando:</p><pre>docker-compose up -d</pre><p>Então teremos a seguinte saída no terminal:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/366/1*hZuovyhAGHJInJnOaK1ZOg.png" /></figure><p>Pornto nosso ambiente foi criado.</p><p><strong>Configurando a Replicação de dados</strong></p><p>Vamos criar uma tabela e habilitar o CDC no nosso banco SQL Server, utilizando o seguinte script:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LT9sofGf06U7zcLGGOxiLA.png" /></figure><p>Ao executar temos as seguintes mensagens:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/362/1*RewUgICrkY5kgdZaxp86hg.png" /></figure><p>Agora vamos configurar o conector do SQL Server executando o seguinte <em>script</em>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AADmjs4m7PakfM3xE7j4WQ.png" /></figure><p>Acessando o <a href="http://localhost:19000/"><strong>KAFDROP</strong></a><strong> </strong>podemos visualizar a criação do tópico em que será direcionado as alterações na tabela <strong>PESSOA</strong>, o <a href="http://localhost:9000/topic/dbserver.dbo.PESSOA"><strong>dbserver.dbo.PESSOA</strong></a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sMdi9IUNrEzRhw1xiXIvzA.png" /></figure><p>E uma mensagem referente ao <em>insert </em>e ao<em> update </em>executado no script <strong>SQL </strong>acima.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*whAxCvN-WdPqY3tc1KiL8A.png" /></figure><p>Agora vamos configurar o conector do MongoDB, utilizando o seguinte script:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_gSd7ix3FDnm7eVjv0fqHA.png" /></figure><p>Agora podemos visualizar o nosso dado replicado no MongoDB acessando o <a href="http://localhost:8081/">MONGO-EXPRESS</a>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ew2wCnUWKouV5Sab9B8IsQ.png" /></figure><p><strong>Repositório</strong></p><p><a href="https://github.com/LauanGuermandi/DatabaseReplicationSqlServerToMongoDB">GitHub - LauanGuermandi/DatabaseReplicationSqlServerToMongoDB</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d33e1fe2131" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>