request limit net core

.NET CORE - Controle de limite de solicitação

Os relatórios são muito comuns em qualquer sistema e alguns deles podem ser muito pesados ​​para processar. Portanto, neste caso, o aplicativo pode ser degradado durante a geração do relatório, afetando outros usuários. Mas, como podemos evitar isso? O primeiro pensamento seria bloquear o fundo, certo? Hum, mas é tão fácil hackear, o usuário pode apenas editar os adereços HTML e habilitá -lo novamente. Portanto, a melhor opção é bloqueá -lo no lado do servidor, usando algumas estratégias de controle de limite de solicitação.

Solução - AspnetCoreratelimit

AspNetCoreRateLimit é uma biblioteca que pode nos ajudar no controle de requisição. Você pode definir regras para decidir quantas vezes um cliente pode chamar o recurso por um período de tempo.

Mas como funciona?

O ASPNETCORERATELIMIT usa a solução MemoryCache para salvar informações sobre as solicitações do cliente. Por exemplo, um cliente pode fazer apenas 10 solicitações em um intervalo de 5 segundos para um terminal específico. Assim, cada solicitação será salva no cache da memória e, se o cliente exceder esse limite, o aplicativo interromperá a solicitação e retornará um status de erro HTTP.

Implementação

Primeiro de tudo, precisamos instalar a biblioteca aspnetCoreratelimit

Configurando

A melhor opção para configurar aspnetCoreratelimit é definir todas as informações no appSettings.json. Então, vamos criar um bloco como este:

 "IpRateLimiting": {
    "EnableEndpointRateLimiting": true,
    "StackBlockedRequests": false,
    "RealIpHeader": "X-Real-IP",
    "ClientIdHeader": "X-ClientId",
    "HttpStatusCode": 429, 
    "GeneralRules": [
      {
        "Endpoint": "*/api/test", 
        "Period": "2s", //interval
        "Limit": 2 //limit of request in the interval
      }
    ]
  },

Com nossas regras configuradas, precisamos adicionar poucas linhas no Startup.cs :

 public void ConfigureServices(IServiceCollection services)
 {
      services.AddOptions();
      //AspNetCoreRateLimit uses MemoryCache to control the numbers of requests
      services.AddMemoryCache();

       //Adding AspNetCoreRateLimit rules
      services.Configure<IpRateLimitOptions>(Configuration.GetSection("IpRateLimiting"));

      //Adding the store
      services.AddSingleton<IIpPolicyStore, MemoryCacheIpPolicyStore>();

      //Adding the request counter
      services.AddSingleton<IRateLimitCounterStore, MemoryCacheRateLimitCounterStore>();
      services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
      services.AddHttpContextAccessor();
      services.AddControllers();
      services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
      services.AddSwaggerGen(c =>
      {
          c.SwaggerDoc("v1", new OpenApiInfo { Title = "RequestLimit", Version = "v1" });
      });
}

E a etapa final é ativar o serviço:

 public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
        app.UseSwagger();
        app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "RequestLimit v1"));
    }

    app.UseHttpsRedirection();

    app.UseRouting();
    app.UseIpRateLimiting() //Adding this block;
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

E está feito, agora nossa API tem um controle de solicitação. Você pode personalizar sua configuração para seguir as regras específicas, todas as opções estão listadas aqui: https://github.com/stefanprodan/aspnetcoreratelimit