如何在ASP.NET Core 7 Kestrel中为指定端点设置高优先级？

方法1：利用ASP.NET Core 7内置请求优先级机制 #

ASP.NET Core 7原生支持请求优先级配置，结合Kestrel的调度逻辑可实现高优先级请求插队处理，这是最推荐的方案，无需额外维护自定义队列，性能更优。

步骤1：编写请求优先级中间件 #

创建中间件识别目标端点/API/something_important，将其请求优先级设为High：

public class RequestPriorityMiddleware
{
    private readonly RequestDelegate _next;

    public RequestPriorityMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Path.StartsWithSegments("/API/something_important", StringComparison.OrdinalIgnoreCase))
        {
            context.Request.Priority = HttpRequestPriority.High;
        }
        await _next(context);
    }
}

// 扩展方法用于注册中间件
public static class RequestPriorityMiddlewareExtensions
{
    public static IApplicationBuilder UseRequestPriority(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<RequestPriorityMiddleware>();
    }
}

步骤2：在Program.cs中配置并注册 #

确保中间件在管道早期注册，同时根据负载配置Kestrel的并发限制：

var builder = WebApplication.CreateBuilder(args);

// 配置Kestrel并发参数，根据实际负载调整
builder.WebHost.ConfigureKestrel(options =>
{
    options.Limits.MaxConcurrentConnections = 1000;
    options.Limits.MaxConcurrentRequestsPerConnection = 10;
});

builder.Services.AddControllers();

var app = builder.Build();

// 优先级中间件放在管道最前端
app.UseRequestPriority();

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

原理说明 #

请求标记为HttpRequestPriority.High后，Kestrel底层调度器会优先处理该类请求，即使队列中有普通优先级请求，高优先级请求也会被插队执行。

方法2：自定义优先级队列（适用于精细化控制场景） #

如果需要自定义优先级级别、队列容量限制等更灵活的逻辑，可以实现独立的请求队列和调度机制。

步骤1：实现优先级队列服务 #

public interface IPriorityRequestQueue
{
    Task EnqueueAsync(HttpContext context, HttpRequestPriority priority);
    Task<HttpContext> DequeueAsync(CancellationToken cancellationToken);
}

public class PriorityRequestQueue : IPriorityRequestQueue
{
    private readonly Channel<(HttpContext Context, HttpRequestPriority Priority)> _channel;

    public PriorityRequestQueue()
    {
        var options = new BoundedChannelOptions(1000)
        {
            FullMode = BoundedChannelFullMode.Wait,
            SingleReader = true,
            SingleWriter = false
        };
        _channel = Channel.CreateBounded<(HttpContext, HttpRequestPriority)>(options);
    }

    public async Task EnqueueAsync(HttpContext context, HttpRequestPriority priority)
    {
        await _channel.Writer.WriteAsync((context, priority));
    }

    public async Task<HttpContext> DequeueAsync(CancellationToken cancellationToken)
    {
        var reader = _channel.Reader;
        while (await reader.WaitToReadAsync(cancellationToken))
        {
            if (reader.TryRead(out var item))
            {
                // 可扩展为多子队列实现严格优先级排序，此处为简化逻辑
                return item.Context;
            }
        }
        throw new OperationCanceledException();
    }
}

步骤2：编写调度中间件 #

public class PriorityDispatchMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IPriorityRequestQueue _queue;
    private readonly IHostApplicationLifetime _lifetime;

    public PriorityDispatchMiddleware(RequestDelegate next, IPriorityRequestQueue queue, IHostApplicationLifetime lifetime)
    {
        _next = next;
        _queue = queue;
        _lifetime = lifetime;
        _ = ProcessQueueAsync();
    }

    public async Task InvokeAsync(HttpContext context)
    {
        var priority = context.Request.Path.StartsWithSegments("/API/something_important", StringComparison.OrdinalIgnoreCase)
            ? HttpRequestPriority.High
            : HttpRequestPriority.Normal;

        await _queue.EnqueueAsync(context, priority);
        await context.RequestAborted.WaitHandle.WaitOne();
    }

    private async Task ProcessQueueAsync()
    {
        var cancellationToken = _lifetime.ApplicationStopping;
        while (!cancellationToken.IsCancellationRequested)
        {
            try
            {
                var context = await _queue.DequeueAsync(cancellationToken);
                await _next(context);
                await context.Response.CompleteAsync();
            }
            catch (OperationCanceledException)
            {
                break;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"请求处理出错: {ex.Message}");
            }
        }
    }
}

public static class PriorityDispatchMiddlewareExtensions
{
    public static IApplicationBuilder UsePriorityDispatch(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<PriorityDispatchMiddleware>();
    }
}

步骤3：在Program.cs中注册使用 #

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton<IPriorityRequestQueue, PriorityRequestQueue>();
builder.Services.AddControllers();

var app = builder.Build();

app.UseHttpsRedirection();
app.UsePriorityDispatch();
app.UseAuthorization();
app.MapControllers();

app.Run();

注意事项 #

• 自定义队列需设置合理容量，避免请求堆积导致内存溢出。
• 后台调度任务需做好异常捕获，防止单个请求失败导致整个调度流程中断。

关键验证点 #

• 配置完成后，可通过日志监控高优先级请求的处理时长，确认插队逻辑生效。
• 根据实际负载调整Kestrel的并发参数，避免资源不足导致高优先级请求无法及时处理。

内容的提问来源于stack exchange，提问作者Rob The Quant