0Pricing
C# Academy · Aula

Middleware e filtros em Minimal APIs

Adicione autenticação, autorização, tratamento de exceções e filtros de endpoint aos pipelines de Minimal API.

Middleware e filtros em Minimal APIs é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Componentes Intermediários vs Filtros de Pontos de Acesso

O ASP.NET Core tem duas camadas de extensibilidade: componentes intermediários (envolvem toda a cadeia de processamento e são executados para cada solicitação) e filtros de pontos de acesso (são executados apenas para pontos de acesso específicos). Ambos funcionam nas APIs Minimalistas.

Adicionando Componentes Intermediários às APIs Minimalistas

Os componentes intermediários padrão do ASP.NET Core são adicionados com métodos app.Use*. A ordem é importante: os componentes intermediários são executados na ordem em que são registrados.

var app = builder.Build();

app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();
app.UseRateLimiter();

app.MapGet("/secure", () => "Protected endpoint")
   .RequireAuthorization();

app.Run();

Filtros de Pontos de Acesso Embutidos

Os filtros de pontos de acesso são como componentes intermediários restritos a um único ponto de acesso. Use AddEndpointFilter para adicionar um filtro embutido. Os filtros podem interromper o processamento antecipadamente retornando um resultado sem chamar next.

app.MapGet("/guarded", () => "Secret data")
   .AddEndpointFilter(async (ctx, next) =>
   {
       var header = ctx.HttpContext.Request.Headers["X-Api-Key"];
       if (header != "my-secret-key")
           return Results.Unauthorized();

       return await next(ctx); // proceed to handler
   });

Filtros de Pontos de Acesso Baseados em Classe

Implemente IEndpointFilter para criar filtros reutilizáveis. Eles podem ser aplicados a pontos de acesso individuais ou a grupos de rotas inteiros.

public class LoggingFilter : IEndpointFilter
{
    private readonly ILogger<LoggingFilter> _logger;
    public LoggingFilter(ILogger<LoggingFilter> logger) => _logger = logger;

    public async ValueTask<object?> InvokeAsync(
        EndpointFilterInvocationContext ctx,
        EndpointFilterDelegate next)
    {
        _logger.LogInformation("Before: {Path}", ctx.HttpContext.Request.Path);
        var result = await next(ctx);
        _logger.LogInformation("After: {Path}",  ctx.HttpContext.Request.Path);
        return result;
    }
}

// Apply to a group
app.MapGroup("/api").AddEndpointFilter<LoggingFilter>();

Componente Intermediário de Tratamento de Exceções

Use app.UseExceptionHandler ou o componente intermediário integrado ProblemDetails para capturar exceções não tratadas e retornar respostas de erro no formato RFC 7807.

builder.Services.AddProblemDetails();

var app = builder.Build();

app.UseExceptionHandler();
// OR for custom logic:
app.UseExceptionHandler(errApp =>
    errApp.Run(async ctx =>
    {
        var ex = ctx.Features.Get<IExceptionHandlerFeature>()?.Error;
        ctx.Response.StatusCode = 500;
        await ctx.Response.WriteAsJsonAsync(new { error = ex?.Message });
    }));

Componente Intermediário de Interrupção Antecipada

Use app.MapShortCircuit() (.NET 8+) ou Results.StatusCode() em um filtro para retornar imediatamente uma resposta sem executar toda a cadeia de processamento.

// Block known bad bots at the edge
app.MapGet("/robots.txt", () => "User-agent: *\nDisallow: /")
   .ShortCircuit(); // .NET 8: returns response immediately

// Or in a filter:
app.MapGet("/maintenance", () => "OK")
   .AddEndpointFilter((ctx, next) =>
       ValueTask.FromResult<object?>(Results.StatusCode(503)));

Limitação de Taxa no .NET 7+

O componente intermediário integrado de limitação de taxa protege os pontos de acesso contra uso indevido. Aplique políticas globalmente ou por ponto de acesso com RequireRateLimiting().

using System.Threading.RateLimiting;

builder.Services.AddRateLimiter(opt =>
{
    opt.AddFixedWindowLimiter("fixed", o =>
    {
        o.PermitLimit     = 10;
        o.Window          = TimeSpan.FromSeconds(10);
        o.QueueLimit      = 0;
        o.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
    });
    opt.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
});

app.UseRateLimiter();
app.MapGet("/search", Search).RequireRateLimiting("fixed");

Configuração de CORS

Configure políticas de CORS nos serviços e aplique-as globalmente ou por ponto de acesso para controlar quais origens podem acessar sua API.

builder.Services.AddCors(opt =>
    opt.AddPolicy("AllowFrontend", policy =>
        policy.WithOrigins("https://myapp.com")
              .AllowAnyHeader()
              .AllowAnyMethod()));

app.UseCors("AllowFrontend");

// Or per endpoint:
app.MapGet("/public-data", () => "data")
   .RequireCors("AllowFrontend");

Componente Intermediário de Cache de Saída

AddOutputCache armazena respostas em cache no servidor. Aplique-o a pontos de acesso específicos para fornecer respostas armazenadas em cache sem acessar o banco de dados a cada solicitação.

builder.Services.AddOutputCache();

app.UseOutputCache();

app.MapGet("/products", async (AppDbContext db) =>
    Results.Ok(await db.Products.AsNoTracking().ToListAsync()))
   .CacheOutput(p => p.Expire(TimeSpan.FromMinutes(5)));

Ordem e Encadeamento de Filtros

Os filtros são executados na ordem em que são adicionados (do mais externo primeiro e do mais interno por último, como os componentes intermediários). Você pode encadear vários filtros no mesmo ponto de acesso ou grupo.

app.MapPost("/orders", CreateOrder)
   .AddEndpointFilter<LoggingFilter>()      // runs first
   .AddEndpointFilter<ValidationFilter>()   // runs second
   .AddEndpointFilter<AuthFilter>()         // runs third
   .RequireAuthorization();                 // JWT checked by middleware

Mundo Real: Componente Intermediário de Chave de API

Um componente intermediário reutilizável de chave de API que lê a chave de um cabeçalho e encerra o processamento com 401 caso ela seja inválida.

public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string _expectedKey;

    public ApiKeyMiddleware(RequestDelegate next, IConfiguration cfg)
    {
        _next = next;
        _expectedKey = cfg["ApiKey"] ?? throw new Exception("ApiKey not configured");
    }

    public async Task InvokeAsync(HttpContext ctx)
    {
        if (!ctx.Request.Headers.TryGetValue("X-Api-Key", out var key)
            || key != _expectedKey)
        {
            ctx.Response.StatusCode = 401;
            await ctx.Response.WriteAsync("Invalid API key");
            return;
        }
        await _next(ctx);
    }
}

app.UseMiddleware<ApiKeyMiddleware>();

Verificação Rápida

Qual é a principal diferença entre componentes intermediários e filtros de pontos de acesso nas APIs Minimalistas?

Resumo: Componentes Intermediários e Filtros

Principais conclusões:

  • Os componentes intermediários (UseX) são executados globalmente, na ordem da cadeia de processamento, para cada solicitação
  • Os filtros de pontos de acesso (AddEndpointFilter) são restritos a pontos de acesso ou grupos específicos
  • Implemente IEndpointFilter para criar classes de filtros reutilizáveis e compatíveis com DI
  • Componentes intermediários integrados: limitação de taxa, CORS, cache de saída e tratamento de exceções
  • A ordem dos filtros é importante: eles são aninhados como componentes intermediários (o primeiro adicionado fica mais externo)

Perguntas Frequentes

A aula “Middleware e filtros em Minimal APIs” é grátis?

Sim — o texto completo de “Middleware e filtros em Minimal APIs” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Middleware e filtros em Minimal APIs”?

Adicione autenticação, autorização, tratamento de exceções e filtros de endpoint aos pipelines de Minimal API. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Middleware e filtros em Minimal APIs”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Criando sua primeira Minimal API
  2. Grupos de rotas, parâmetros e validação
  3. Middleware e filtros em Minimal APIs
  4. OpenAPI, versionamento e implantação
← Voltar para C# Academy