> ## Content Index > Fetch the complete content index at: https://www.azurebrasil.cloud/llms.txt > Use this file to discover other available public pages before exploring further. # Middleware no ASP.NET Core: Entendendo o Pipeline Completo da Aplicação - URL: https://www.azurebrasil.cloud/blog/middleware-no-asp-net-core-entendendo-o-pipeline-completo-da-aplicacao/ - Published: 2026-06-25T12:42:54.000Z - Updated: 2026-06-25T12:42:54.000Z - Description: Entenda como funciona o pipeline de requisições do ASP.NET Core e descubra por que os middlewares são fundamentais para autenticação, logs, segurança, tratamento de erros e muito mais. - Author: Charlison Fideles de Oliveira Se existe um conceito fundamental dentro do ASP.NET Core, ele é o Middleware. Independentemente de você estar construindo uma API REST, uma Minimal API, um sistema MVC ou até mesmo aplicações em tempo real com SignalR, o pipeline de middlewares com certeza vai estar presente em todas as requisições. Muitos desenvolvedores utilizam middlewares diariamente muitas vezes sem perceber. Recursos como autenticação, autorização, tratamento de exceções, logs, compressão de resposta e CORS são implementados justamente através desse mecanismo. Entender como o pipeline funciona é essencial para criar aplicações mais organizadas, performáticas e fáceis de manter. ## O que é um Middleware? Middleware é um componente responsável por interceptar uma requisição HTTP durante sua passagem pela aplicação. Ele atua como uma etapa intermediária entre o cliente e o endpoint final. Quando uma requisição chega ao servidor, ela não é enviada diretamente para um Controller ou Endpoint. Antes disso, ela percorre uma sequência de componentes conhecidos como pipeline de middlewares. Cada middleware pode: - Executar alguma lógica antes da requisição continuar. - Interromper o fluxo. - Modificar a requisição. - Modificar a resposta. - Executar lógica após a execução dos próximos componentes. Visualmente, o fluxo funciona assim: ```chsarp Request ↓ Middleware A ↓ Middleware B ↓ Middleware C ↓ Endpoint ↑ Middleware C ↑ Middleware B ↑ Middleware A ↑ Response ``` Perceba que o caminho de ida e volta passa pelos mesmos componentes. Esse comportamento é conhecido como Pipeline Pattern. ## Por que o ASP.NET Core utiliza Middlewares? Antes do ASP.NET Core, a maioria das funcionalidades eram acopladas diretamente ao IIS e ao próprio framework. Com a chegada do ASP.NET Core, a Microsoft adotou uma arquitetura modular onde cada funcionalidade pode ser adicionada ou removida individualmente conforme a sua necessidade. Isso trouxe uma serie de benefícios importantes: - Menor consumo de recursos. - Melhor performance. - Maior flexibilidade. - Pipeline totalmente configurável. - Facilidade para criação de componentes personalizados. Na prática, sua aplicação carrega apenas aquilo que realmente precisa durante a execução. ## Como funciona o Pipeline de Requisições? O pipeline é construído dentro do arquivo Program.cs. Exemplo: ```csharp var builder = WebApplication.CreateBuilder(args); var app = builder.Build(); app.UseHttpsRedirection(); app.UseAuthentication(); app.UseAuthorization(); app.MapControllers(); app.Run(); ``` A ordem é extremamente importante. Cada middleware executa exatamente na sequência em que foi registrado. Uma configuração incorreta pode gerar problemas difíceis de identificar. Por exemplo: ```csharp app.UseAuthorization(); app.UseAuthentication(); ``` Nesse caso a autorização será executada antes da autenticação, o que fará com que o usuário nunca seja identificado corretamente. ## O Delegate RequestDelegate Internamente, todo middleware trabalha sobre um objeto chamado RequestDelegate. Sua assinatura é simples: ```csharp public delegate Task RequestDelegate(HttpContext context); ``` Esse delegate representa o próximo middleware da cadeia. Sempre que chamamos: ```csharp await next(context); ``` estamos encaminhando a execução para o próximo componente do pipeline. ## O Objeto HttpContext O HttpContext representa toda a requisição atual. Através dele podemos acessar: ```csharp context.Request context.Response context.User context.Session context.Items ``` Exemplo: ```csharp var ip = context.Connection.RemoteIpAddress; var path = context.Request.Path; ``` Praticamente todos os middlewares trabalham manipulando informações presentes no HttpContext. ## Principais Métodos de Configuração ### Use() Permite continuar o pipeline. ```csharp app.Use(async (context, next) => { Console.WriteLine("Antes"); await next(); Console.WriteLine("Depois"); }); ``` É o método mais comum para construção de middlewares. ### Run() Encerra o pipeline. ```csharp app.Run(async context => { await context.Response.WriteAsync("Fim do pipeline"); }); ``` Nenhum middleware após esse será executado. ### Map() Cria ramificações no pipeline. ```csharp app.Map("/admin", admin => { admin.Run(async context => { await context.Response.WriteAsync("Área administrativa"); }); }); ``` ### MapWhen() Executa um pipeline alternativo baseado em condições. ```csharp app.MapWhen( context => context.Request.Query.ContainsKey("debug"), branch => { branch.Run(async context => { await context.Response.WriteAsync("Modo Debug"); }); }); ``` ## Principais Middlewares Nativos O ASP.NET Core possui diversos middlewares prontos. ### Exception Handler Tratamento global de exceções. ```csharp app.UseExceptionHandler("/error"); ``` Evita exposição de detalhes internos da aplicação. ### HTTPS Redirection Redireciona HTTP para HTTPS. ```csharp app.UseHttpsRedirection(); ``` Fundamental para segurança. ### Static Files Permite servir arquivos estáticos. ```csharp app.UseStaticFiles(); ``` Utilizado para: - CSS - JavaScript - Imagens - PDFs ### Routing Responsável por localizar endpoints. ```csharp app.UseRouting(); ``` ### Authentication Realiza autenticação. ```csharp app.UseAuthentication(); ``` ### Authorization Valida permissões. ```csharp app.UseAuthorization(); ``` ### CORS Controla acesso entre domínios. ```csharp app.UseCors(); ``` Muito utilizado em APIs consumidas por aplicações frontend. ### Response Compression Comprime respostas HTTP. ```csharp app.UseResponseCompression(); ``` ## Onde Utilizar Middlewares? Middlewares são ideais para funcionalidades transversais, também chamadas de Cross-Cutting Concerns. Exemplos: - Logging - Auditoria - Monitoramento - Segurança - Autenticação - Rate Limiting - Tratamento de exceções - Cache - Compressão - Métricas - Rastreamento de requisições Sempre que uma funcionalidade precisa ocorrer em várias rotas, middleware costuma ser uma excelente escolha. ## Onde NÃO Utilizar? Nem tudo deve ser middleware. Evite quando: ### Existe regra de negócio Errado: ```csharp if(cliente.LimiteCredito < valor) ``` Esse tipo de validação pertence ao domínio. ### Lógica específica de um endpoint Se apenas uma rota utiliza determinada regra, ela provavelmente deve ficar no endpoint ou service. ### Operações pesadas Middlewares executam em todas as requisições. Consultas desnecessárias ao banco podem impactar significativamente a performance. ## Vantagens ### Reutilização Uma única implementação atende toda aplicação. ### Organização Cada responsabilidade fica isolada. ### Manutenção simplificada Alterações são centralizadas. ### Baixo acoplamento Os componentes não dependem uns dos outros. ### Alta extensibilidade Novos comportamentos podem ser adicionados facilmente. ## Desvantagens ### Ordem de execução crítica Um posicionamento incorreto pode gerar falhas. ### Debug mais complexo À medida que o pipeline cresce, rastrear problemas se torna mais difícil. ### Impacto em performance Middlewares excessivos aumentam o tempo de processamento. ### Possibilidade de responsabilidades incorretas Muitos desenvolvedores acabam colocando regras de negócio dentro do pipeline. ## Principais Bibliotecas Relacionadas Diversas bibliotecas populares utilizam middlewares internamente. ### Serilog Logs estruturados. ```csharp app.UseSerilogRequestLogging(); ``` ### Swagger Documentação de APIs. ```csharp app.UseSwagger(); app.UseSwaggerUI(); ``` ### Polly Resiliência e retry. Frequentemente utilizado em conjunto com HttpClient. ### AspNetCoreRateLimit Controle de limite de requisições. Protege APIs contra abuso. ### Health Checks Monitoramento de saúde da aplicação. ```csharp app.MapHealthChecks("/health"); ``` ### OpenTelemetry Observabilidade distribuída. Integração com Grafana, Jaeger e Prometheus. ## Problemas que Middleware Resolve Imagine uma API com 50 endpoints. Sem middleware: ```csharp _logger.LogInformation(...); try { } catch { } ``` Repetido em todos os endpoints. Além da duplicação, a manutenção se torna difícil. Com middleware: ```csharp app.UseMiddleware(); ``` Todo tratamento fica centralizado. # Exemplo Prático com Minimal API Vamos criar um middleware que registra tempo de execução das requisições. ### Middleware ```csharp public class RequestTimingMiddleware { private readonly RequestDelegate _next; private readonly ILogger _logger; public RequestTimingMiddleware( RequestDelegate next, ILogger logger) { _next = next; _logger = logger; } public async Task InvokeAsync(HttpContext context) { var stopwatch = Stopwatch.StartNew(); await _next(context); stopwatch.Stop(); _logger.LogInformation( "Endpoint: {Path} - Tempo: {Elapsed} ms", context.Request.Path, stopwatch.ElapsedMilliseconds); } } ``` Extensão ```csharp public static class MiddlewareExtensions { public static IApplicationBuilder UseRequestTiming( this IApplicationBuilder app) { return app.UseMiddleware(); } } ``` ### Program.cs ```csharp var builder = WebApplication.CreateBuilder(args); builder.Services.AddEndpointsApiExplorer(); var app = builder.Build(); app.UseRequestTiming(); app.MapGet("/products", async () => { await Task.Delay(500); return Results.Ok(new[] { "Notebook", "Mouse", "Teclado" }); }); app.Run(); ``` ### Resultado Ao acessar: ```csharp GET /products ``` O log exibirá algo semelhante: ```csharp Endpoint: /products - Tempo: 503 ms ``` Esse exemplo demonstra um cenário extremamente comum em ambientes corporativos: monitoramento de desempenho de requisições. A partir dessa base seria possível evoluir para: - Auditoria completa. - Correlation ID. - Métricas Prometheus. - OpenTelemetry. - Distributed Tracing. - Monitoramento de APIs em produção. ## Conclusão Middleware é um dos pilares arquiteturais do ASP.NET Core. Ele permite construir aplicações modulares, desacopladas e altamente configuráveis através de um pipeline de processamento de requisições. Recursos essenciais como autenticação, autorização, logs, tratamento de erros, compressão e monitoramento são implementados sobre esse conceito. Dominar o pipeline significa entender exatamente como cada requisição percorre sua aplicação. Esse conhecimento permite criar APIs mais robustas, melhorar a observabilidade do sistema, reduzir duplicação de código e implementar funcionalidades transversais de forma elegante. Em aplicações modernas construídas com Minimal APIs, MVC ou microserviços, conhecer profundamente os middlewares deixou de ser um diferencial e passou a ser um requisito fundamental para qualquer desenvolvedor ASP.NET Core. ## Código-fonte do projeto Para facilitar o entendimento, disponibilizei o projeto completo com o exemplo de **Middleware**, já organizado com separação de responsabilidades e boas práticas: 👉 **Baixar o projeto no GitHub** [**neste link**](https://github.com/charlisonOliveira/MiddlewareMinimalApi-BLOG?ref=azurebrasil.cloud)**:** ## Quer ver mais conteúdos como este? Se você trabalha com **.NET, C# e backend**, este blog seguirá trazendo conteúdos práticos e objetivos sobre o **ecossistema Microsoft**, com foco em código, boas práticas e decisões técnicas aplicadas ao mundo real. Acompanhe para continuar aprofundando seu domínio sobre a plataforma **.NET**.