(ASP.NET Core) 속도 제한 설정(Rate limiting middleware)

namespace Rate_limiting_Example.Services
{
    public interface IGetTimeService
    {
        /// <summary>
        /// 현재 시간 반환
        /// </summary>
        /// <returns></returns>
        TimeOnly currentTime();
    }

    public class GetTimeService : IGetTimeService
    {
        public GetTimeService()
        {
        }

        public TimeOnly currentTime()
        {
            // TimeOnly 구조체 : 하루 시간 단위를 나타내는 구조체
            return TimeOnly.FromDateTime(DateTime.Now);
        }
    }
}

..[생략]..

// GetTimeService 서비스 등록
builder.Services.AddScoped<IGetTimeService, GetTimeService>();

..[생략]..

namespace Rate_limiting_Example.Controllers
{
    using Microsoft.AspNetCore.Mvc;
    using Microsoft.AspNetCore.RateLimiting;
    using System.Threading.RateLimiting;
    using Rate_limiting_Example.Services;

    [ApiController]
    public class TimeController : Controller
    {
        private readonly IGetTimeService _service;

        public TimeController(IGetTimeService service)
        {
            _service = service;
        }

        [HttpGet]
        [Route("[controller]/time-current")]
        public IActionResult Index()
        {
            return Ok(_service.currentTime());
        }
    }
}

namespace Rate_limiting_Example
{
    using Microsoft.AspNetCore.RateLimiting;
    using Rate_limiting_Example.Services;
    using System.Globalization;
    using System.Net;
    using System.Threading.RateLimiting;

    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            // Add services to the container.

            builder.Services.AddControllers();
            // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
            builder.Services.AddEndpointsApiExplorer();
            builder.Services.AddSwaggerGen();
            
            // GetTimeService 서비스 등록
            builder.Services.AddScoped<IGetTimeService, GetTimeService>();
            
            // Fixed window limit 알고리즘 방식으로 속도 제한 처리
            builder.Services.AddRateLimiter(_ => _
            .AddFixedWindowLimiter(policyName: "LimiterPolicy", options =>
            {
                // 요청 허용 갯수 : 1
                options.PermitLimit = 1;
                // 창 이동시간 10초 [10초 동안 최대 1개의 요청만 처리 가능]
                options.Window = TimeSpan.FromSeconds(10);
                options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
                // 제한시 3개의 요청만 대기열에 추가
                options.QueueLimit = 3;
            }));

            var app = builder.Build();
            // 속도 제한 사용
            app.UseRateLimiter();

            // Configure the HTTP request pipeline.
            if (app.Environment.IsDevelopment())
            {
                app.UseSwagger();
                app.UseSwaggerUI();
            }

            app.UseHttpsRedirection();

            app.UseAuthorization();


            app.MapControllers();


            app.Run();
        }
    }
}

[ApiController]
// LimiterPolicy 이름의 RateLimiter 적용
[EnableRateLimiting("LimiterPolicy")]
public class TimeController : Controller
{
  ..[생략]..
}

// Sliding window limit 알고리즘 방식으로 속도 제한 처리
builder.Services.AddRateLimiter(_ => _
.AddSlidingWindowLimiter(policyName: "LimiterPolicy", options =>
{
    // 요청 허용 갯수 : 100
    options.PermitLimit = 100;
    // 창 이동시간 30초
    options.Window = TimeSpan.FromSeconds(30);
    // 창 분할 세그먼트 갯수
    options.SegmentsPerWindow = 3;  // 1개의 세그먼트 : 30s / 3
    options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
    // 제한시 3개의 요청만 대기열에 추가
    options.QueueLimit = 3;
}));

namespace Rate_limiting_Example
{
    public class MyRateLimitOptions
    {
        public const string MyRateLimit = "MyRateLimit";
        public int PermitLimit { get; set; } = 100;
        public int Window { get; set; } = 10;
        public int ReplenishmentPeriod { get; set; } = 2;
        public int QueueLimit { get; set; } = 2;
        public int SegmentsPerWindow { get; set; } = 8;
        public int TokenLimit { get; set; } = 10;
        public int TokensPerPeriod { get; set; } = 4;
        public bool AutoReplenishment { get; set; } = false;
    }
}

// 환경설정 'MyRateLimit' 섹션 내용 바인딩
var myOptions = new MyRateLimitOptions();
builder.Configuration.GetSection(MyRateLimitOptions.MyRateLimit).Bind(myOptions);

// 환경설정 'MyRateLimit' 섹션 내용 바인딩
var myOptions = new MyRateLimitOptions();
builder.Configuration.GetSection(MyRateLimitOptions.MyRateLimit).Bind(myOptions);

builder.Services.AddRateLimiter(limiterOptions =>
{
    // 글로벌 속도 제한 설정
    limiterOptions.GlobalLimiter = PartitionedRateLimiter.Create<HttpContext, IPAddress>(context =>
    {
        // 요청 IPAddress
        IPAddress? remoteIpAddress = context.Connection.RemoteIpAddress;

        // 요청된 IPAddress가 루프백이 아닌 경우
        if (IPAddress.IsLoopback(remoteIpAddress!) == false)
        {
            // IPAddress에 대해 속도 제한 설정 [Fixed window limit 알고리즘 적용]
            return RateLimitPartition.GetFixedWindowLimiter
            (remoteIpAddress!, _ =>
            new FixedWindowRateLimiterOptions
            {
                // 요청 허용 갯수 : 1
                PermitLimit = myOptions.PermitLimit,
                // 창 이동시간 10초 [10초 동안 최대 1개의 요청만 처리 가능]
                Window = TimeSpan.FromSeconds(myOptions.Window),
                QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
                // 제한시 3개의 요청만 대기열에 추가
                QueueLimit = myOptions.QueueLimit,
            });
        }

        // 루프백 IPAddress는 속도 제한 없음.
        return RateLimitPartition.GetNoLimiter(IPAddress.Loopback);
    });
});

var app = builder.Build();
// 속도 제한 사용
app.UseRateLimiter();

..[이하 생략]..

// 환경설정 'MyRateLimit' 섹션 내용 바인딩
var myOptions = new MyRateLimitOptions();
builder.Configuration.GetSection(MyRateLimitOptions.MyRateLimit).Bind(myOptions);

builder.Services.AddRateLimiter(limiterOptions =>
{
    // 요청이 속도 제한 초과시 호출되는 OnRejected 콜백
    limiterOptions.OnRejected = (context, cancellationToken) =>
    {
        if (context.Lease.TryGetMetadata(MetadataName.RetryAfter, out var retryAfter))
        {
            context.HttpContext.Response.Headers.RetryAfter =
                ((int)retryAfter.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo);
        }
    
        context.HttpContext.Response.StatusCode = StatusCodes.Status429TooManyRequests;
        return ValueTask.CompletedTask;
    };
    
    ..[이하 생략]..
};

namespace Rate_limiting_Example
{
    using Microsoft.AspNetCore.Http;
    using Microsoft.AspNetCore.RateLimiting;
    using Microsoft.Extensions.Options;
    using System;
    using System.Threading;
    using System.Threading.RateLimiting;
    using System.Threading.Tasks;

    public class CustomRateLimiterPolicy : IRateLimiterPolicy<string>
    {
        private readonly MyRateLimitOptions _options;
        private Func<OnRejectedContext, CancellationToken, ValueTask>? _onRejected;

        public CustomRateLimiterPolicy(IOptions<MyRateLimitOptions> options)
        {
            // 요청이 속도 제한 초과시 호출되는 OnRejected 콜백
            _onRejected = (context, cancellationToken) =>
            {
                context.HttpContext.Response.StatusCode = StatusCodes.Status429TooManyRequests;
                return ValueTask.CompletedTask;
            };
            _options = options.Value;
        }

        public Func<OnRejectedContext, CancellationToken, ValueTask>? OnRejected => _onRejected;

        public RateLimitPartition<string> GetPartition(HttpContext httpContext)
        {
            // 특정 유저 정보 (Header, JWT 등)를 읽어서 속도 제한 설정 처리

            var username = "anonymous user";
            if (httpContext.User.Identity?.IsAuthenticated is true)
            {
                username = httpContext.User.ToString()!;
            }

            return RateLimitPartition.GetFixedWindowLimiter(string.Empty,
                _ => new FixedWindowRateLimiterOptions
                {
                    // 요청 허용 갯수 : 1
                    PermitLimit = _options.PermitLimit,
                    //    // 창 이동시간 10초 [10초 동안 최대 1개의 요청만 처리 가능]
                    Window = TimeSpan.FromSeconds(_options.Window),
                    QueueProcessingOrder = QueueProcessingOrder.OldestFirst,
                    //    // 제한시 3개의 요청만 대기열에 추가
                    QueueLimit = _options.QueueLimit,
                });
        }
    }
}

// 환경설정 'MyRateLimit' 섹션 내용 의존성 주입 서비스 등록
builder.Services.Configure<MyRateLimitOptions>(
    builder.Configuration.GetSection(MyRateLimitOptions.MyRateLimit));
    
// 환경설정 'MyRateLimit' 섹션 내용 바인딩
var myOptions = new MyRateLimitOptions();
    builder.Configuration.GetSection(MyRateLimitOptions.MyRateLimit).Bind(myOptions);
    
builder.Services.AddRateLimiter(limiterOptions =>
{
    // 속도 제한 정책 등록
    limiterOptions.AddPolicy<string, CustomRateLimiterPolicy>("CustomLimiter");
});



var app = builder.Build();
// 속도 제한 사용
app.UseRateLimiter();

[ApiController]
[EnableRateLimiting("CustomLimiter")]
public class TimeController : Controller