<?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 Luis Felipe Sales on Medium]]></title>
        <description><![CDATA[Stories by Luis Felipe Sales on Medium]]></description>
        <link>https://medium.com/@salesluis?source=rss-22c451f3a70b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*D8vZU-3JUQlxWOp0VzD7LQ.jpeg</url>
            <title>Stories by Luis Felipe Sales on Medium</title>
            <link>https://medium.com/@salesluis?source=rss-22c451f3a70b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 05:25:18 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@salesluis/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[Transactional Outbox em .NET: construindo fluxos mais resilientes entre banco e serviços externos]]></title>
            <link>https://salesluis.medium.com/transactional-outbox-em-net-construindo-fluxos-mais-resilientes-entre-banco-e-servi%C3%A7os-externos-5153d47ffd19?source=rss-22c451f3a70b------2</link>
            <guid isPermaLink="false">https://medium.com/p/5153d47ffd19</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[arquitetura-de-software]]></category>
            <category><![CDATA[teste-de-software]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[postgresql]]></category>
            <dc:creator><![CDATA[Luis Felipe Sales]]></dc:creator>
            <pubDate>Fri, 04 Sep 2026 16:33:56 GMT</pubDate>
            <atom:updated>2026-09-16T19:09:28.136Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introdução</h3><p>Em sistemas distribuídos, uma mesma ação de negócio normalmente precisa alterar dados persistidos e gerar um efeito externo. Um cadastro de usuário, por exemplo, precisa salvar o usuário no banco e enviar um e-mail de confirmação. Parece simples, mas uma falha entre essas duas etapas pode deixar o sistema em um estado inconsistente.</p><p>Neste artigo irei mostrar o padrão <strong>Transactional Outbox</strong>, como ele resolve esse problema de forma simples e mostro como o implementei em .NET 10, PostgreSQL, Entity Framework Core e um Worker em background. O exemplo usa o cadastro de usuários e a simulação de envio de e-mails de confirmação, mas a mesma estratégia pode ser aplicada à publicação em filas, brokers e integrações com outros serviços.</p><p><a href="https://github.com/salesluis/TransactionalOutboxPattern">link para o repositório</a></p><h3>O problema: duas operações, uma única intenção de negócio</h3><p>Conforme o exemplo dado acima, vamos considerar um endpoint de cadastro que executa esta sequência simples:</p><ol><li>Salva o usuário no banco de dados.</li><li>Envia um e-mail de confirmação.</li></ol><p>Uma primeira intuição poderia ser parecida com esta:</p><pre>app.MapPost(&quot;/bad/user&quot;, async (<br>    AppDbContext db, <br>    IEmailService emailService, <br>    Request request) =&gt;<br>{<br>    try<br>    {<br>        var newUser = new User(request.Name, request.Email);<br>        await db.Users.AddAsync(newUser);<br>        await db.SaveChangesAsync();<br>        // Se aqui falhar: o usuário foi criado no banco de dados <br>        // e o email de confirmação nao pode ser enviado<br>        // Problema: temos dados inconsistentes<br>        await emailService.SendEmailAsync(request.Email, &quot;cadastro realizado&quot;);<br>        Results.Created();<br>    }</pre><p>O problema é que quando o banco confirma a criação do usuário, mas o serviço de e-mail falha ou fica indisponível. O usuário existe, porém o efeito externo esperado não aconteceu. Reexecutar a requisição não se torna viável, pois pode gerar duplicidade ou exigir que o cliente conheça detalhes de implementação expondo regra de negócio para o código cliente.</p><p>Essa é uma variação do problema de <strong>dual write</strong>: duas escritas em recursos diferentes sem uma transação atômica que garanta a consistência entre elas.</p><h3>A ideia do Transactional Outbox</h3><p>O padrão Transactional Outbox transforma o efeito externo em uma mensagem persistida no mesmo banco de dados da operação principal.</p><pre>app.MapPost(&quot;/good/user&quot;, async (<br>    IUserRepository repository, <br>    Request request) =&gt;<br>{<br>    try<br>    {<br>        var newUser = new User(request.Name, request.Email);<br>        var outbox = new OutBoxUsers(<br>            newUser.Id,<br>            EEventType.CreateUser,<br>            new Payload(<br>                newUser.Name,<br>                newUser.Email,<br>                &quot;criado usuario&quot;,<br>                newUser.CreatedAt));<br>        <br>        await repository.CreateUserAndOutboxAsync(newUser, outbox);<br>        Results.Created();<br>    }</pre><p>Ao invés de salvar o usuário e enviar o e-mail na mesma requisição, a aplicação salva o usuário e uma mensagem de outbox na mesma transação local, garantindo atomicidade na operação. Depois, um processo independente lê as mensagens pendentes, executa o efeito externo e atualiza o status da mensagem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HJNkh3MzSnhAuXTtoRFjVw.png" /></figure><p>Com isso, se a chamada ao serviço externo falhar, a mensagem continua no banco com status pendente. O Worker poderá tentar novamente em um ciclo posterior, sem perder a intenção original do negócio.</p><h3>A implementação do projeto</h3><p>A solução foi dividida em quatro projetos:</p><ul><li>TransactionalOutbox.Api Recebe as requisições HTTP e inicia o fluxo de cadastro</li><li>TransactionalOutbox.Core Contém entidades, DTOs, contratos e enums de domínio</li><li>TransactionalOutbox.Infra Implementa persistência com EF Core/PostgreSQL, migrations, repositórios e o serviço de e-mail</li><li>TransactionalOutbox.Worker Processa as mensagens pendentes em segundo plano</li></ul><p>A aplicação é conteinerizada, dentro do projeto TransactionalOutbox.Api e TransactionalOutbox.Worker existe seus respectivos Dockerfile que monta as imagens da aplicação, enquanto um docker compose na raiz do projeto orquestra tudo, o PostgreSQL também é iniciado pelo Docker Compose e armazena tanto os usuários quanto as mensagens de outbox.</p><h3>Persistindo a operação principal e a mensagem</h3><p>No fluxo resiliente, disponível em POST /good/user funciona de forma simples:</p><ol><li>a API cria um User e uma entidade OutBoxUsers.</li><li>A mensagem registra o identificador do usuário, o tipo de evento, um payload e o status inicial Pending para que seja processado posteriormente pelo Worker.</li></ol><p>Como o Entity Framework Core agrupa essas mudanças em uma transação em memória, o usuário e a mensagem são confirmados juntos. Se a persistência falhar, nenhum dos dois registros é criado.</p><h3>Estrutura da outbox</h3><p>A tabela outbox_users armazena, entre outros, os campos abaixo:</p><ul><li>id Identificador único da mensagem.</li><li>user_id Usuário relacionado ao evento.</li><li>event_type Tipo do evento, como CreateUser.</li><li>payload Dados do evento em jsonb.</li><li>status Estado do processamento: PENDING, PROCESSING, PROCESSED ou FAILED.</li><li>created_at Momento em que a mensagem foi criada.</li><li>processed_at Momento em que o processamento foi concluído.</li></ul><p>Também há um índice que inclui status, tipo de evento e data de processamento, favorecendo a busca das mensagens aguardando processamento.</p><h3>Processamento assíncrono pelo Worker</h3><p>O projeto TransactionalOutbox.Worker registra um BackgroundService que, a cada cinco segundos, ele consulta até 100 registros com status Pending, ordenados pela data de criação.</p><p>Para cada mensagem, o Worker:</p><ol><li>Obtém o payload salvo na outbox.</li><li>Executa o efeito externo — neste exemplo, chama IEmailService.</li><li>Marca a mensagem como processada e preenche ProcessedAt.</li><li>Persiste a alteração de status.</li></ol><pre>var pendingMessages = await dbContext<br>      .OutboxUsers<br>      .Where(m =&gt; m.Status == EOutboxStatus.Pending)<br>      .OrderBy(o =&gt; o.CreatedAt)<br>      .Take(BatchSize)<br>      .ToListAsync(cancellationToken: ct);<br>if (pendingMessages.Count == 0)<br>{<br>    logger.LogInformation(&quot;Nenhum outbox encontrado.&quot;);<br>    return;<br>}<br><br>foreach (var outbox in pendingMessages)<br>{<br>    try<br>    {<br>        await emailService.SendEmailAsync(<br>            outbox.Payload.Email,<br>            outbox.Payload.Message<br>        );<br><br>        outbox.MarkAsProcessed();<br>        await dbContext.SaveChangesAsync(ct);<br>    }<br>    catch (Exception e)<br>    {<br>        logger.LogError(e, $&quot;Falha ao processar a outbox {outbox.Id}&quot;);<br>    }<br>}</pre><p>Na implementação atual, EmailService é propositalmente uma simulação e apenas registra o envio nos logs. Em produção, essa abstração poderia integrar um provedor de e-mail, publicar em Kafka/RabbitMQ, ou chamar uma API externa.</p><h3>O que esta abordagem garante — e o que ela não garante</h3><p>O Transactional Outbox garantepelo menos uma ve que o dado de negócio e a intenção de publicar/processar o evento sejam persistidos juntos. Se o commit for bem-sucedido, a mensagem estará disponível para processamento, mesmo que o serviço externo esteja indisponível naquele instante.</p><p>Por outro lado, essa implementação ainda tem pontos que devem ser considerados antes de produção:</p><ul><li>O processamento é <strong>pelo menos uma vez</strong>. Se o serviço externo concluir a ação e a aplicação falhar antes de marcar a mensagem como processada, ela poderá ser reenviada.</li><li>O consumidor ou serviço externo deve ser idempotente, ou receber uma chave de idempotência baseada no id da outbox.</li><li>Com múltiplas instâncias do Worker, seria necessário um mecanismo de reserva/lock das mensagens, por exemplo FOR UPDATE SKIP LOCKED ou atualização atômica para PROCESSING.</li><li>Falhas permanentes podem exigir contagem de tentativas, backoff exponencial, uma data para a próxima tentativa e uma fila/tabela de mensagens mortas.</li><li>Observabilidade é essencial: métricas para mensagens pendentes, taxa de falha, tempo até o processamento e alertas ajudam a detectar atrasos.</li></ul><p>Esses cuidados não invalidam o exemplo; eles mostram como evoluir uma arquitetura para uma solução adequada ao volume e às garantias exigidas pelo sistema, garantindo um sistema muito mais resiliente e protegido a falhas.</p><h3>Resultados dos testes internos</h3><p>Para testar e validar a aplicação eu criei um arquivo na raiz do projeto usando o recurso file-based apps do .NET 10 e testar um numero alto de requisições simultaneas.</p><p>Ao executar esse teste de carga feito manualmente, o EF conseguiu lidar com a maioria das requisições.</p><p>rodando o teste de carga pode-se perceber isso:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U1zM7cHOcIJT9nUSTFGb5Q.png" /></figure><p>O comportamento do worker foi como esperado:</p><p>Antes de rodar o teste de carga</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0GMJTyu6xUOkoQgUOSYESw.png" /></figure><p>após rodar o script ele comecou o processamento em lote</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YKJxdL4JuqDJl_dC84oFEA.png" /></figure><h3>Conclusão</h3><p>O Transactional Outbox é uma alternativa prática para manter a consistência entre uma transação de banco de dados e efeitos externos, sem depender de transações distribuídas. A ideia central é simples: registrar a intenção de publicar um evento no mesmo commit da mudança de negócio e delegar a entrega a um processo assíncrono.</p><p>Neste projeto, o padrão foi aplicado ao cadastro de usuários e envio de e-mails. A estrutura permite evoluir para outros tipos de eventos e integrações, mantendo a confiabilidade como parte explícita do desenho da aplicação.</p><h3>Referências</h3><ul><li><a href="https://microservices.io/patterns/data/transactional-outbox.html">Documentação oficial do padrão Transactional Outbox</a></li><li><a href="https://learn.microsoft.com/ef/core/saving/transactions">Documentação do Entity Framework Core sobre transações</a></li><li><a href="https://www.npgsql.org/efcore/">Documentação do Npgsql para EF Core</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5153d47ffd19" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Como eu estruturar seus agentes de IA com .NET e Microsoft Agent Framework com baixo acoplamento]]></title>
            <link>https://salesluis.medium.com/como-eu-estruturar-seus-agentes-de-ia-com-net-e-microsoft-agent-framework-com-baixo-acoplamento-185430243c67?source=rss-22c451f3a70b------2</link>
            <guid isPermaLink="false">https://medium.com/p/185430243c67</guid>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[backend-architecture]]></category>
            <dc:creator><![CDATA[Luis Felipe Sales]]></dc:creator>
            <pubDate>Thu, 13 Aug 2026 01:15:24 GMT</pubDate>
            <atom:updated>2026-08-13T01:15:24.341Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Fluxo da aplicação" src="https://cdn-images-1.medium.com/max/1024/1*Kek36q4Nws0RAENp6JUTNg.png" /><figcaption>fluxograma de orquestração de agentes</figcaption></figure><p>Construir um agente que responde uma pergunta é simples. O problema começa quando o mesmo agente precisa entender intenção, recomendar produtos, consultar estoque, acessar banco de dados e ainda devolver o formato exato esperado pela API.</p><p>Quando toda essa responsabilidade fica em um único prompt, o modelo deixa de ser uma peça da aplicação e começa a virar a própria arquitetura. Cada regra nova aumenta o contexto. Cada ferramenta nova amplia o acesso. Uma alteração pequena pode mudar comportamentos que não tinham nenhuma relação com ela.</p><p>No meu projeto de recomendação de cafés com .NET, Ollama, Microsoft Agent Framework, Entity Framework Core, PostgreSQL e pgvector, escolhi outro caminho. Organizei o fluxo com um agente roteador, agentes especialistas, tools e um caso de uso responsável pela coordenação.</p><p>A regra central é esta: o LLM interpreta e redige, mas o código continua controlando o sistema.</p><h3>Como o fluxo funciona</h3><p>A requisição entra em POST /v1/prompt e segue este caminho:</p><pre>PromptRoute<br>    ↓<br>HandlePromptUseCase<br>    ↓<br>RouterAgent<br>    ↓<br>GenericAgent, RecomendationAgent ou InventoryAgent<br>    ↓<br>Tools<br>    ↓<br>Ollama e PostgreSQL com pgvector</pre><p>O RouterAgent não responde ao usuário. Ele classifica a pergunta como recomendação, busca no estoque ou mensagem genérica. Depois, o caso de uso valida se a intenção devolvida pertence à lista conhecida. Se o modelo responder algo inesperado, o fluxo cai no agente genérico.</p><p>Esse detalhe é importante. O prompt orienta o modelo, mas o C# confirma a decisão. Afinal uma saida probabilística não deveria controlar diretamente uma operação da aplicação, correto?</p><h3>Um agente para cada responsabilidade</h3><p>O GenericAgent responde mensagens gerais e não possui tools.</p><p>O RecomendationAgent usa uma ferramenta de busca semântica. A pergunta vira um embedding, o PostgreSQL calcula a distância de cosseno e devolve os três produtos mais próximos.</p><p>O InventoryAgent pode procurar um produto pelo nome exato ou fazer uma busca vetorial quando o usuário descreve o que deseja ao invés do nome do produto em específico.</p><p>Essa separação se aproxima do padrão Strategy. Cada agente representa uma estratégia para uma intenção. O caso de uso escolhe qual comportamento executar em tempo de execução.</p><p>O benefício não é apenas organização de pastas. Cada especialista recebe um prompt menor e apenas as ferramentas necessárias. O agente de estoque não precisa conhecer as regras de recomendação. O agente genérico não precisa acessar o banco. O negócio fica menos acoplado e a superfície para comportamento inesperado diminui.</p><h3>Uma receita comum para criar agentes</h3><p>Todos os especialistas herdam de AgentCreator. Essa classe mantém a construção comum e deixa cada implementação definir apenas o prompt e as tools:</p><pre>public abstract class AgentCreator(string uri, string model)<br>{<br>    protected abstract string SystemPrompt { get; }<br>    protected abstract AITool[] Tools { get; }<br><br>    public ChatClientAgent CreateAgent() =&gt; new<br>            OllamaApiClient(uri, model)<br>            .AsAIAgent(SystemPrompt, tools: Tools);<br>}</pre><p>Aqui aparece o Template Method. O processo geral de criação permanece fixo, enquanto as subclasses fornecem as partes variáveis.</p><p>Já o AgentFactory mantém um registro com todos os agentes e devolve o correspondente a cada nome. Ela funciona como fábrica e como catálogo. O caso de uso depende de IAgentFactory, então não precisa conhecer a construção de cada especialista.</p><p>O histórico do projeto mostra por que isso importa. As tools já usaram estado estático e métodos de inicialização. Hoje elas são serviços com escopo, recebem ApplicationDbContext e OllamaApiClient pelo construtor e respeitam o ciclo de vida da requisição. Injeção de dependência aqui evita estado global e torna as visíveis.</p><h3>Tools separam decisão de execução</h3><p>O agente decide que precisa consultar um produto. A tool define como essa consulta acontece.</p><p>O LLM não recebe um DbContext, não escreve SQL e não escolhe quantos registros voltarão. Essa fronteira é uma das partes mais importantes de um sistema com agentes. O modelo trabalha com linguagem. O código é que executa ações concretas. O banco continua responsável pelos dados.</p><h3>Todos os agentes falam o mesmo contrato</h3><p>Embora os especialistas façam trabalhos diferentes, todos devolvem o mesmo formato com summary e items. Esse contrato é representado por um DTO que usei para normalizar as respostas do meu agente e facilitar a leitura no front end.</p><p>O prompt exige JSON puro, mas a aplicação não encerra a validação no prompt. O caso de uso desserializa a resposta e verifica resumo, lista e campos obrigatórios. Se o modelo quebrar o contrato, a API devolve 502 em vez de fingir que recebeu uma resposta vazia válida.</p><p>O sobre o CancellationToken, ele também também atravessa as camadas Route, UseCases, Agents, geração de embeddings e consultas do Entity Framework Core. Se o cliente abandonar a requisição, o processamento pode ser interrompido a qualquer momento, afinal num sistema desse o tempo de resposta não é 100% previsível, um usuário pode ficar impaciente e fechar o navegador, tratar isso ajuda a economizar recursos que poderiam ser gastos desnecessáriamente. Se o usuário cancela, a execução dos agentes cancelam também.</p><h3>Os pontos positivos</h3><ol><li>Os agentes possuem responsabilidades pequenas.</li><li>Cada agente recebe somente as tools necessárias.</li><li>O roteamento do modelo passa por uma lista fechada de intenções.</li><li>Factory e Template Method centralizam criação e registro.</li><li>Tools isolam linguagem natural de acesso ao core do sistema.</li><li>Um DTO único estabiliza a resposta da API.</li><li>Configuração com Options Pattern permite modelos diferentes por função e valida tudo na inicialização..</li><li>Cancelamento e erros externos são tratados de forma explícita.</li></ol><h3>Os pontos de atenção</h3><ol><li>As intenções ainda são strings mágicas e uma delas usa a grafia recomendation.</li><li>IAgentFactory devolve ChatClientAgent, vazando um tipo concreto do framework.</li><li>AgentCreator cria OllamaApiClient diretamente, então a troca de provedor ainda custa alteração de código.</li><li>As tools dependem diretamente do Entity Framework Core e do Ollama, o que dificulta testes unitários.</li><li>Entidades completas podem carregar dados demais para o modelo.</li><li>Os prompts vivem dentro das classes e ainda não possuem uma rotina de avaliação.</li><li>O fluxo faz duas inferências por pergunta, uma no roteador e outra no especialista.</li></ol><p>Esses limites não anulam a arquitetura. Eles mostram a passagem de uma prova de conceito organizada para um sistema pronto para produção.</p><h3>O que podemos tirar desse conceito:</h3><p>Estruturar agentes com .NET não significa criar várias classes com Agent no nome e sim decidir onde a incerteza do modelo ajuda e onde ela precisa ser contida.</p><p>O modelo é bom para entender uma frase e explicar uma recomendação. O código é melhor para validar intenções, controlar ferramentas, proteger contratos e representar falhas. O banco é melhor para consultar dados e calcular similaridade vetorial.</p><p>Factory, Strategy, Template Method, injeção de dependência, DTOs e casos de uso continuam relevantes. Na verdade, componentes probabilísticos tornam essas fronteiras ainda mais importantes.</p><p>Ponderações: esse artigo visa mostrar um conceito de organização e arquitetura usada para criação e orquestração de multiplos agentes usando arquitetura de software, padrões de projetos e boas práticas.</p><p>repositório para consulta: <a href="https://github.com/salesluis/pg-vector-with-csharp-recomendation-system">https://github.com/salesluis/pg-vector-with-csharp-recomendation-system</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=185430243c67" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Performance em APIs .NET — Reduzindo Tráfego com DTOs e Projeção no EF Core]]></title>
            <link>https://salesluis.medium.com/performance-em-apis-net-reduzindo-tr%C3%A1fego-com-dtos-e-proje%C3%A7%C3%A3o-no-ef-core-3ebf7f9ce580?source=rss-22c451f3a70b------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ebf7f9ce580</guid>
            <category><![CDATA[dto]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[arquitetura-de-software]]></category>
            <category><![CDATA[web-performance]]></category>
            <dc:creator><![CDATA[Luis Felipe Sales]]></dc:creator>
            <pubDate>Tue, 19 May 2026 15:29:14 GMT</pubDate>
            <atom:updated>2026-05-20T13:34:13.846Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iBvPSlRx7lz7SJ9eznHCaw.png" /></figure><p>APIs projetadas para suportar alto volume de requisições simultâneas exigem que decisões de performance sejam tomadas na arquitetura — não como otimização posterior. Isso vale igualmente para aplicações menores: o custo de ignorar esses padrões no início é proporcionalmente maior quando o volume cresce. Entre as técnicas disponíveis no ecossistema .NET, duas das mais impactantes envolvem o controle preciso de quais dados transitam entre banco de dados e cliente.</p><h3>O Problema do Retorno Irrestrito de Dados</h3><p>Por padrão, o EF Core retorna a entidade completa — todos os campos mapeados — independente do que o endpoint realmente precisa. Em operações de leitura, isso implica três custos distintos: tráfego desnecessário entre banco e aplicação, alocação de memória para dados que serão descartados, e serialização de campos que não deveriam sair da camada de dados.</p><p>Além do payload, o EF Core mantém por padrão o <em>change tracking</em>: uma cópia interna de cada entidade carregada, usada para detectar alterações e gerar os comandos de UPDATE correspondentes. Em consultas de leitura pura, esse mecanismo é overhead puro. O AsNoTracking() desativa esse rastreamento:</p><p>csharp</p><pre>var users = await _dbContext.User.AsNoTracking().ToListAsync();</pre><p>A melhoria é real, mas insuficiente para o problema central: a entidade completa ainda é carregada e retornada.</p><h3>Projeção com Select e DTOs</h3><p>A solução é projetar apenas os campos necessários diretamente na query, usando um DTO (ou ViewModel) como tipo de destino. O EF Core traduz o Select para uma query SQL com colunas explícitas — o banco retorna apenas o que foi pedido, e nenhum dado extra percorre a rede ou ocupa memória na aplicação:</p><p>csharp</p><pre>var users = await _dbContext.User<br>    .AsNoTracking()<br>    .Select(p =&gt; new UserListDto<br>    {<br>        Id = p.Id,<br>        Name = p.Name,<br>        IsEmailVerified = p.IsEmailVerified<br>    })<br>    .ToListAsync();</pre><p>O resultado é um contrato explícito entre o endpoint e o banco de dados:</p><p>json</p><pre>[<br>  {<br>    &quot;id&quot;: &quot;guid-formatado-aqui&quot;,<br>    &quot;name&quot;: &quot;Luis Felipe Sales&quot;,<br>    &quot;isEmailVerified&quot;: true<br>  }<br>]</pre><p>Vale notar que ao usar Select com projeção para um tipo não mapeado, o AsNoTracking() torna-se tecnicamente redundante — o EF Core não rastreia tipos que não são entidades. Mantê-lo é uma escolha de legibilidade e intenção explícita, não de comportamento.</p><p>A nomenclatura — DTO, ViewModel, Response — é irrelevante para o compilador e para o EF. O que importa é o princípio: tipos específicos por contexto, sem vazar a entidade de domínio para fora da camada de dados.</p><h3>Conclusão</h3><p>O uso de DTOs não é apenas uma boa prática de organização de código — é uma decisão de arquitetura com impacto direto na saúde da aplicação em produção. Ao projetar apenas os campos necessários via Select, você elimina uma categoria inteira de desperdício: dados transitando pela rede, ocupando memória e sendo serializados sem nenhuma utilidade para aquele contexto. Combinado com AsNoTracking(), essa abordagem remove tanto o overhead do change tracking quanto o excesso de payload, duas fontes de pressão que se acumulam de forma silenciosa à medida que o volume de requisições cresce.</p><p>O que torna esse padrão especialmente valioso é que ele força uma conversa explícita sobre o contrato de dados de cada endpoint. Ao invés de expor sua entidade de domínio diretamente — o que acopla a API ao modelo interno e vaza informações que não deveriam sair do banco — você passa a modelar intencionalmente o que cada operação precisa receber e retornar. Isso é performance, mas também é design.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ebf7f9ce580" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Embeddings e Busca Vetorial — Do Conceito à Implementação de RAG com C#]]></title>
            <link>https://salesluis.medium.com/embeddings-e-busca-vetorial-do-conceito-%C3%A0-implementa%C3%A7%C3%A3o-de-rag-com-c-7c039ba71898?source=rss-22c451f3a70b------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c039ba71898</guid>
            <category><![CDATA[vector-embeddings]]></category>
            <category><![CDATA[semantic-search]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[dotnet]]></category>
            <dc:creator><![CDATA[Luis Felipe Sales]]></dc:creator>
            <pubDate>Mon, 27 Apr 2026 19:46:42 GMT</pubDate>
            <atom:updated>2026-04-27T19:46:42.578Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GMGIXH8oDhXiD5gaNZwt0A.png" /></figure><h3>Introdução</h3><p>A inteligência artificial generativa revolucionou a forma como interagimos com dados não estruturados. No entanto, o verdadeiro poder dos Modelos de Linguagem de Grande Escala (LLMs) não reside apenas na sua capacidade de gerar texto fluido, mas na habilidade de conectá-los ao conhecimento proprietário da sua empresa. É aqui que entram os conceitos de <strong>Embeddings</strong>, <strong>Busca Vetorial</strong> e <strong>RAG</strong> (Retrieval-Augmented Generation).</p><p>Neste artigo, vamos explorar a semântica por trás desses termos, entender como a matemática da similaridade de cosseno e do vizinho mais próximo (KNN) funciona e, por fim, como integrar tudo isso em uma aplicação .NET utilizando C#.</p><h3>1. O motor Semântico: Entendendo os Embeddings</h3><p>Para que um computador processe a linguagem natural, ele precisa transformar palavras em números. Um <strong>Embedding</strong> é uma representação numérica densa de significado. Imagine um mapa tridimensional onde o eixo X representa “realeza”, o eixo Y “gênero” e o eixo Z “idade”. Nesse espaço, as palavras “Rei” e “Rainha” estariam muito próximas, diferindo apenas no eixo de gênero.</p><p>Na prática, modelos de embedding modernos como o mxbai-embed-large mapeiam textos para vetores com milhares de dimensões dependendo do modelo usado. Esse processo transforma sentenças complexas em coordenadas matemáticas num espaço de alta dimensionalidade. Textos com significados semelhantes estarão geometricamente próximos nesse espaço vetorial.</p><h3>2. A Bússola da Similaridade: Cosseno e KNN</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/815/1*torzJAEPbw190UNhxq7LnA.png" /></figure><p>Uma vez que temos nossos textos convertidos em vetores (embeddings), como encontramos a informação mais relevante para uma determinada pergunta? É aqui que entra a busca vetorial.</p><h3>Similaridade de Cosseno</h3><p>A <strong>Similaridade de Cosseno</strong> é a métrica para comparar embeddings. Em vez de medir a distância euclidiana (a distância em linha reta entre dois pontos), o cosseno mede o <strong>ângulo</strong> entre dois vetores.</p><p>A vantagem do cosseno é que ele ignora a magnitude do vetor. Um documento longo e um documento curto que falam exatamente sobre o mesmo assunto terão vetores de tamanhos diferentes, mas apontarão para a mesma direção semântica.</p><h3>K-Nearest Neighbors (KNN)</h3><p>O <strong>KNN (K-Vizinhos Mais Próximos)</strong> é o algoritmo utilizado para recuperar os resultados. Quando um usuário faz uma pergunta, transformamos essa pergunta em um vetor (usando o mesmo modelo de embedding). Em seguida, o algoritmo varre o banco de dados vetorial calculando a similaridade de cosseno entre o vetor da pergunta e todos os vetores armazenados, retornando os <em>K</em> resultados mais próximos.</p><h3>3. RAG (Retrieval-Augmented Generation)</h3><p>O <strong>Retrieval-Augmented Generation (RAG)</strong> é um padrão de arquitetura que resolve o problema das alucinações e do conhecimento desatualizado dos LLMs.</p><p>Pense em um LLM como um advogado brilhante, mas que não tem memória fotográfica de todos os processos da sua empresa. O RAG atua como um assistente que vai até o arquivo (banco de dados vetorial), encontra os documentos exatos referentes ao caso (usando KNN e Cosseno) e os coloca na mesa do advogado antes que ele responda ao cliente.</p><p>O fluxo do RAG consiste em:</p><ol><li><strong>Indexação:</strong> Dividir documentos em pedaços (<em>chunks</em>), gerar embeddings para cada pedaço e armazená-los em um Vector DB.</li><li><strong>Recuperação (Retrieval):</strong> Converter a pergunta do usuário em um vetor e buscar os <em>chunks</em> mais similares.</li><li><strong>Geração (Augmentation):</strong> Injetar os <em>chunks</em> recuperados no prompt do LLM junto com a pergunta original, instruindo o modelo a responder com base apenas no contexto fornecido.</li></ol><h3>4. Mão na Massa: Implementação em .NET</h3><p>Para desenvolvedores .NET, o ecossistema está maduro. Ferramentas como o <strong>Semantic Kernel</strong>, <strong>MAF(Microsoft Agents Framework)</strong> da Microsoft facilitam enormemente a orquestração de RAG.</p><p>No link abaixo tem um projeto super simples onde uso essa técnica para fazer um sistema de recomendação de cafés usando linguagem natural.</p><p>O projeto em questão usa o banco de dados postgres com a extenção pgvector para armazenar dados vetoriais em um campo da tabela recomendations, como a integração com o ecossistema .NET já está madura, existe também o tipo especial Vector vindo de Microsoft.SemanticKernel.Connectors.PgVector, onde existem metodos que podem ser usado para facilitar, como .CosineDistance para busca por Similaridade de Cosseno.</p><p>Repo: <a href="https://github.com/salesluis/pg-vector-with-csharp-recomendation-system">https://github.com/salesluis/pg-vector-with-csharp-recomendation-system</a></p><h3>Conclusão</h3><p>A integração de Embeddings e busca vetorial em aplicações .NET não é apenas uma “feature legal”, mas o alicerce para construir sistemas corporativos inteligentes baseados em RAG. Ao dominar a semântica por trás do cálculo de cosseno e da busca por vizinhos mais próximos, o desenvolvedor C# transcende a simples chamada de APIs e passa a projetar arquiteturas cognitivas robustas.</p><p>O futuro do desenvolvimento de software envolve não apenas armazenar dados, mas armazenar <strong>significados</strong>. E a matemática vetorial é a linguagem desse novo paradigma.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c039ba71898" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[IEnumerable vs IQueryable: Como a escolha da interface impacta a tradução de SQL e a performance no…]]></title>
            <link>https://salesluis.medium.com/ienumerable-vs-iqueryable-como-a-escolha-da-interface-impacta-a-tradu%C3%A7%C3%A3o-de-sql-e-a-performance-no-9fc32deb0fbd?source=rss-22c451f3a70b------2</link>
            <guid isPermaLink="false">https://medium.com/p/9fc32deb0fbd</guid>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[entity-framework-core]]></category>
            <category><![CDATA[csharp]]></category>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[dotnet]]></category>
            <dc:creator><![CDATA[Luis Felipe Sales]]></dc:creator>
            <pubDate>Wed, 15 Apr 2026 12:58:37 GMT</pubDate>
            <atom:updated>2026-04-15T20:13:50.216Z</atom:updated>
            <content:encoded><![CDATA[<h3>IEnumerable vs IQueryable: Como a escolha da interface impacta a tradução de SQL e a performance no EF</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VNh-q_LBQUfeCBpwwdBn0g.png" /></figure><h3>Introdução</h3><p>Antes do LINQ, desenvolvedores C# precisavam alternar constantemente entre diferentes paradigmas e sintaxes: SQL para bancos de dados, XPath/XQuery para XML, APIs específicas para coleções em memória.</p><p>Cada fonte de dados exigia uma abordagem diferente, sem verificação em tempo de compilação e com alto risco de erros em runtime.</p><p>O LINQ trouxe vantagens como IntelliSense, verificação de tipos em tempo de compilação, sintaxe fortemente tipada e consistente.</p><p>O LINQ foi implementado no .NET Framework 3.5 em 2007, com o objetivo de resolver um problema fundamental dos desenvolvedores da época: as diferentes formas de consultar e manipular coleções de dados, tanto para fontes de dados <strong>internas</strong> (carregadas na memória) — onde se implementa a interface IEnumerable&lt;T&gt;, quanto para <strong>externas</strong> (fontes de outros serviços) – onde se implementa IQueryable ou IQueryable&lt;T&gt;.</p><h3>IEnumerable vs IQueryable</h3><p>Essas duas interfaces são bases para manipulações de coleções de dados como filtragem, agrupamentos, pedidos, etc… IQueryable também pode ser usada em fonte de dados carregados em memória e não apenas se restringindo a fontes externas</p><ul><li>Consultas LINQ que do tipo IEnumerable&lt;T&gt; executa código <strong>IL (Intermediate Language)</strong> diretamente – Execução em Memória;</li><li>As consultas do tipo IQueryable ou IQueryable&lt;T&gt; implementam o IEnumerable porem gera uma estrutura de dados (a árvore) que será lida por um Provider.</li></ul><p>Se usar um exemplo do banco de dados, o IEnumerable mesmo se fizemos as cláusulas de filtragem, top, etc… ele traria todos os dados para a memória e após isso seria feito os filtros, já o IQueryable faria a filtragem dentro do banco de dados trazendo os dados já tratados e filtrados, o que dependendo da quantidade de dados, pode travar o servidor por falta de RAM e derrubar a aplicação como um todo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/863/1*IfrqDIwghIA9Bur4vS5eHA.png" /></figure><h3>Exemplo</h3><p>Quando se usa <strong>IEnumerable</strong>:</p><pre>IEnumerable&lt;Student&gt; students = dbContext<br>                                    .Students<br>                                    .Where(x =&gt; x.Name == &quot;Luis Felipe&quot;);<br><br>var result = students.Take(2);</pre><p>O SQL gerado não usará a cláusula TOP, então buscará todos os estudantes com nome “Luis Felipe” do SQL Server para a memória e então filtrará os dados em memória</p><p>Quando se usa <strong>IQueryable</strong>:</p><pre>IQueryable&lt;Student&gt; students = dbContext<br>                                   .Students<br>                                   .Where(x =&gt; x.Gender == &quot;Male&quot;);<br>        <br>var result = students.Take(2);</pre><p>O SQL gerado usará a cláusula TOP dentro do banco, trazendo apenas os dados necessários e filtrados.</p><h3>Expression Tree — Árvore de Expressão</h3><p>Quando se escreve uma consulta LINQ sobre IQueryable&lt;T&gt; (como em LINQ to SQL ou Entity Framework), o compilador C# não gera código executável imediatamente.</p><p>Em vez disso, ele constrói uma <strong>árvore de expressão</strong> — uma estrutura de dados hierárquica onde cada nó representa uma operação do seu código como demonstrado <a href="https://github.com/salesluis/ExpressionTree">nesse repositório</a>.</p><p>Por exemplo, x =&gt; x &gt; 5 vira uma árvore com:</p><p>BinaryExpression (GreaterThan)<br>├─ Left: ParameterExpression (x)<br>└─ Right: ConstantExpression (5)</p><h3>Processo de Tradução para SQL</h3><p>O Entity Framework utiliza um pipeline de múltiplas etapas para converter essa árvore em SQL executável:</p><ol><li>O compilador C# cria a Expression&lt;Func&lt;T, bool&gt;&gt; automaticamente quando se usa LINQ sobre IQueryable&lt;T&gt;.</li><li>As lambdas são transformadas em <strong>Expression Trees</strong> em tempo de compilação, compostas por nós como MethodCallExpression, BinaryExpression, MemberExpression e ConstantExpression, sem qualquer semântica de SQL.</li><li>A árvore é instanciada em <strong>runtime</strong>, mas a lógica de como ela é montada é definida pelo compilador. A query permanece inerte por execução diferida até um operador terminal acionar IQueryProvider.Execute() – ToList() ou .First(), que é responsável por “mandar o comando” para o banco. É o motor que consome a árvore.</li><li>O Entity Framework usa o padrão ExpressionVisitor para percorrer recursivamente cada nó da árvore, identificando operações, propriedades acessadas e valores constantes.</li><li>A árvore de expressão .NET é traduzida para um modelo de consulta abstrato e independente de banco (ShapedQueryExpression), que representa conceitos genéricos como SELECT, WHERE, JOIN.</li><li>O provedor específico do banco (Microsoft.EntityFrameworkCore.SqlServer) converte o modelo abstrato para SQL concreto, respeitando: – Sintaxe específica do banco (T-SQL, PL/SQL, etc) – Tipos de dados nativos – Funções proprietárias – Otimizações específicas</li><li><strong>Execução:</strong> Apenas neste momento a query SQL é enviada ao banco de dados.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dZJSFnoXj_7FWdeSxcnUtg.png" /></figure><h3>Conclusão</h3><p>Compreender a diferença entre IEnumerable e IQueryable é fundamental para a construção de aplicações .NET performáticas e escaláveis.</p><p>Enquanto o <strong>IEnumerable</strong> é a ferramenta ideal para manipulação de dados já residentes em memória, o <strong>IQueryable</strong> brilha ao delegar a inteligência da consulta para o provedor de dados, utilizando as <strong>Expression Trees</strong> para traduzir código C# em comandos nativos (como o SQL).</p><p>Em resumo, o uso consciente dessas interfaces evita gargalos críticos de memória e processamento, garantindo que o Entity Framework busque apenas o necessário.</p><p>Entender como esse pipeline de tradução transforma sem duvidas o desenvolvedor de um simples “escritor de código” em um especialista capaz de otimizar a comunicação entre a aplicação e a camada de persistência. Ajudando na tomada de decisão na hora da manipulação de dados.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9fc32deb0fbd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bluefin e o modelo imutável: O que o Linux desktop aprendeu com os containers]]></title>
            <link>https://salesluis.medium.com/bluefin-e-o-modelo-imut%C3%A1vel-como-o-linux-desktop-aprendeu-com-os-containers-24ebf41ba824?source=rss-22c451f3a70b------2</link>
            <guid isPermaLink="false">https://medium.com/p/24ebf41ba824</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[imutabilidade]]></category>
            <dc:creator><![CDATA[Luis Felipe Sales]]></dc:creator>
            <pubDate>Mon, 13 Apr 2026 18:33:24 GMT</pubDate>
            <atom:updated>2026-04-15T11:24:25.382Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/439/1*Xc6eTzKjlMIf6Wcat3INCQ.png" /><figcaption>imagem retirada do site oficial do bluefin</figcaption></figure><p>O mundo da tecnologia tem adotado de forma crescente os conceitos de conteinerização no desenvolvimento de software. Podman (backend padrão do Bluefin) ou Docker, por exemplo, consolidaram um princípio fundamental: <strong>separar o ambiente de execução do sistema subjacente</strong>, garantindo que uma aplicação se comporte de forma idêntica independentemente do sistema operacional em que está hospedada. E se fosse possível aplicar esse mesmo princípio ao próprio desktop Linux?</p><p>O modelo tradicional de distribuições Linux baseia-se na modificação direta da raiz do sistema por gestores de pacotes (apt para bases Debian ou pacman para Arch), um processo que pode resultar em estados de &quot;meio atualizado&quot; ou conflitos de dependências de bibliotecas. A principal diferença entre uma distribuição convencional e uma imutável reside na forma como o sistema lida com os arquivos da raiz e a segurança do processo de atualização. Enquanto as convencionais modificam o sistema em tempo real, as imutáveis, como o <strong>Bluefin</strong>, utilizam um modelo de atualizações atômicas e isolamento por containers, modo de leitura apenas em tempo de execução — e as atualizações ocorrem por meio de imagens completas. A atualização é baixada em segundo plano e só é aplicada no próximo boot. O benefício real é que, se algo falhar, o sistema pode reverter para a imagem anterior (<em>rollback</em>).</p><h3>OSTree: o Git do sistema de arquivos</h3><p>Para entender como essa mágica acontece na prática, é preciso conhecer o componente central que torna tudo isso possível: o <strong>OSTree</strong></p><p>Conceitualmente, o OSTree funciona como um <strong>Git para árvores de arquivos do sistema operacional</strong>. Assim como o Git rastreia cada versão de um repositório de código-fonte por meio de hashes criptográficos (SHA-256), o OSTree rastreia cada versão da árvore do sistema de arquivos raiz. Cada <em>commit</em> no OSTree representa um snapshot completo e imutável da árvore raiz do sistema — incluindo /usr (binários e bibliotecas), com /etc sendo mesclado separadamente a cada atualização e /var permanecendo sempre persistente e fora do controle do OSTree.</p><p>Na prática, o OSTree mantém um repositório local em /ostree/repo, onde cada objeto é armazenado com base no hash do seu conteúdo. Isso tem uma consequência muito eficiente: <strong>arquivos idênticos entre duas versões diferentes do sistema nunca são duplicados</strong>. Se uma atualização modifica apenas 50 pacotes de um total de 2.000, apenas os arquivos alterados são baixados e armazenados — o restante é simplesmente compartilhado por hardlinks entre os dois <em>deployments</em>.</p><p>Cada versão do sistema é representada como um <em>deployment</em>, que nada mais é do que um diretório em /ostree/deploy/&lt;osname&gt;/deploy/&lt;hash&gt;/. O bootloader (geralmente systemd-boot ou GRUB) é configurado para apontar para um desses diretórios como raiz. O sistema atual e o anterior coexistem no disco simultaneamente, o que é o que torna o <em>rollback</em> instantâneo: basta apontar o bootloader para o deployment anterior.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BOKwkkZFhxu4Xk2ejTfUfg.png" /><figcaption>estrutura de pastas do meu sistema dentro do caminho o os-tree</figcaption></figure><p>Vale destacar que o OSTree <strong>não gerencia </strong><strong>/etc e </strong><strong>/var da mesma forma</strong>. O /etc é mesclado de forma inteligente a cada atualização: arquivos modificados pelo usuário são preservados, e novos arquivos do sistema são adicionados — semelhante a um git merge. Já o /var é completamente persistente e nunca tocado pelo OSTree, o que leva diretamente à decisão arquitetural de armazenar os dados do usuário em /var/home.</p><h3>A estrutura de diretórios do Bluefin</h3><p>Seguindo a arquitetura de sistemas baseados em imagens atômicas como o <strong>Fedora Silverblue</strong> (base do <strong>Bluefin</strong>), a pasta de usuários não fica no local tradicional, mas sim em /var/home. O /home na raiz continua existindo como um symlink apontando para /var/home. O sistema organiza os arquivos dessa forma para garantir que os dados do usuário permaneçam persistentes e separados das atualizações de imagem do sistema operacional, criando links simbólicos na raiz do sistema para manter a compatibilidade com softwares que esperam o caminho convencional.</p><figure><img alt="links simbólicos do /" src="https://cdn-images-1.medium.com/max/943/1*MWVfGzqg26x7XMikJIY4SQ.png" /></figure><p>Essa separação não é arbitrária — ela é uma consequência direta do modelo OSTree. Como o /usr é montado como <em>read-only</em> em tempo de execução e gerenciado exclusivamente pelo OSTree, qualquer dado que precise ser mutável (configurações do usuário, arquivos pessoais, logs) precisa residir fora dessa árvore.</p><h3>Distrobox e Homebrew</h3><p>O Bluefin prioriza a instalação de pacotes via flatpak para programas gráficos e o homebrew(popular para desenvolvedores que usam MacOS) para instalação de programas de linha de comandos. O Flatpak já empacota aplicações como containers isolados e o homebrew opera inteiramente em /home/linuxbrew sem tocar o sistema de arquivos raiz reforçando a filosofia imutável do Bluefin, mantendo também o sistema host intocável.</p><p>Surge então uma questão natural: O que fazer quando um software não está disponível em nenhum desses formatos(flatpak, homebrew ou appimage) — especialmente quando usar o dnf diretamente não é uma opção?</p><p>O <strong>Distrobox</strong> desempenha um papel fundamental na experiência do desenvolvedor no Bluefin, atuando como a “ponte” para softwares que não se encaixam nos formatos principais de distribuição. Em um sistema imutável e focado em containers, ele resolve o problema da disponibilidade de pacotes.</p><h3>Distrobox: Acesso Universal a Repositórios de Qualquer Distribuição</h3><p>O Distrobox utiliza tecnologias de container (como Podman ou Docker) para permitir que o desenvolvedor crie um ambiente de qualquer distribuição Linux (como Arch, Debian, Ubuntu ou Fedora) dentro do Bluefin.</p><ul><li>Isso significa que, se um pacote específico está disponível apenas no <strong>AUR (Arch User Repository)</strong> ou em um repositório <strong>.deb</strong> antigo, o desenvolvedor pode simplesmente criar uma “caixa” (box) dessa distro e instalar o pacote usando o gestor nativo daquela versão (como pacman ou apt).</li><li>Esses softwares e suas bibliotecas <strong>nunca se misturam com a estrutura da raiz do sistema operacional</strong>, que permanece intacta e estável. Essa é a grande vantagem do conceito.</li><li><strong>Exportação de Aplicativos e Binários:</strong> É possível integrar as aplicações instaladas dentro do contêiner com o sistema principal. Isso inclui a possibilidade de <strong>exportar binários (para uso no terminal do host) e aplicativos gráficos</strong>, permitindo que softwares complexos, como o DaVinci Resolve, sejam executados de forma transparente como se fossem nativos.</li></ul><h4>Uma mudança de mentalidade</h4><p>O Bluefin e o modelo imutável não representam apenas uma mudança técnica na forma como o sistema de arquivos é organizado e como as atualizações e modificações devem ser feitas — representam uma mudança de mentalidade. A ideia de que um sistema operacional pode ser tratado como uma imagem, versionada, atualizada atomicamente e revertida em caso de falha, é o mesmo princípio que transformou o desenvolvimento de software com containers. Aplicá-lo ao desktop é uma consequência natural dessa evolução.</p><p>A separação entre sistema base, aplicações e ambiente do desenvolvedor — viabilizada pelo Flatpak, Homebrew e Distrobox — não impõe restrições: ela oferece previsibilidade sem sacrificar a flexibilidade que torna o Linux atraente. O sistema permanece intocável enquanto o desenvolvedor continua com acesso irrestrito a qualquer repositório de qualquer distribuição.</p><p>A pergunta que fica não é se esse modelo vai se consolidar, mas quanto tempo levará até que seja o padrão esperado.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=24ebf41ba824" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Criação e Seed de Banco de dados automatizado para ambiente de Desenvolvimento]]></title>
            <link>https://salesluis.medium.com/cria%C3%A7%C3%A3o-e-seed-de-banco-de-dados-automatizado-para-ambiente-de-desenvolvimento-c7479ec92353?source=rss-22c451f3a70b------2</link>
            <guid isPermaLink="false">https://medium.com/p/c7479ec92353</guid>
            <category><![CDATA[docker-compose]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[Luis Felipe Sales]]></dc:creator>
            <pubDate>Mon, 02 Mar 2026 18:14:01 GMT</pubDate>
            <atom:updated>2026-03-02T18:14:01.509Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/554/1*dvy3sq92PaaGBX26kHi7fA.png" /></figure><p>A agilidade no desenvolvimento de software moderno exige que o setup de um projeto seja o mais simples possível. O cenário ideal é o “one-command setup”: clonar o repositório, executar um comando e ter o banco de dados pronto, com schema definido e dados populados.</p><p>Graças à conteinerização, especificamente utilizando a imagem <a href="https://www.google.com/search?q=https://mcr.microsoft.com/mssql-tools"><strong>mcr.microsoft.com/mssql-tools</strong></a> da Microsoft, essa automação é perfeitamente viável para ambientes SQL Server.</p><h3>A Estratégia Técnica</h3><p>Para orquestrar a criação do banco de forma automatizada, utilizamos dois pilares:</p><ol><li><strong>Persistência e Transferência:</strong> O diretório /tmp dentro do container Linux do MSSQL Tools permite operações de gravação. Ao mapear scripts SQL do seu projeto para este diretório via volumes do Docker, tornamos os comandos acessíveis ao container.</li><li><strong>Execução via CLI:</strong> A imagem oficial disponibiliza os utilitários sqlcmd e bcp no caminho /opt/mssql-tools/bin. Eles são as chaves para executar instruções SQL e importar dados em massa diretamente via linha de comando.</li></ol><h3>Orquestração com Bash Scripts dentro do container</h3><p>O grande diferencial está em utilizar um script em <strong>Bash</strong> como ponto de entrada. Este script atua como um orquestrador que:</p><ul><li>Aguarda a inicialização completa da instância do SQL Server.</li><li>Executa os scripts SQL para criar as tabelas.</li><li>Popula o banco com dados sintéticos (fakes) para garantir que o ambiente de teste seja fiel à realidade.</li></ul><p>Essa abordagem elimina a necessidade de subir banco de dados, rodar scripts manuais para criar e popular tabelas e configurando o ambiente. Tudo isso usando conceitos de Docker, SQL, e aproveitando as funcionalidades que o Linux proporciona nativamente.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c7479ec92353" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>