Asp.NET Core – Rate Limit İle API Güvencesi Sağlama

Merhaba,

Asp.NET Core API ile tasarlanmış bir endpoint’in normal şartlarda sürekli istek alabilecek olarak dış dünyaya açık bir şekilde tasarlanması kadar doğal birşey olmasa gerek. Lakin bu durum fiili olarak kötü niyetli kişiler tarafından sürekli eyleme dönüştürülebilir ve Denial Of Service Attack(DOS Attack) ve hatta Distributed Denial Of Service Attack(DDOS Attack) dediğimiz saldırılarla karşı karşıya kalınmasına sebebiyet verebilir.

Nedir bu DOS/DDOS Attack saldırıları? diye sorarsanız eğer şöyle özetleyebiliriz;
Asp.NET Core - Rate Limit İle API Güvencesi Sağlama
Kötü niyetli kişiler tarafından dış dünyaya karşı istek hacmi her daim açık olan bir API tespit edildiği taktirde, bir kaç client veya client görevi görecek tehlikeli(compromised) yazılım eşliğinde ilgili API’a aralıksız istek göndererek hedef sunucuyu çökertmek veya servisi hizmet veremez hale getirmek amaçlı yapılan saldırı çeşitidir. Böylece ilgili sunucu hizmetlere karşılık veremeyecek yahut gecikmeli çalışacak hale getirildiği taktirde kullanıcılara ya yavaş sonuç dönülecek ya da kullanıcılar tarafından erişilemeyecektir.

İşte böyle bir senaryoyla karşılaşmamak için API’larımıza dış dünyadan gelecek isteklerin sınırını belirtmemiz gerekmektedir. Bunun için Rate Limit belirtilerek bu olası saldırıdan rahatça korunulabilir. Rate Limit; uygulamanıza Güvenlik ve Ölçeklendirilebilirlik getirecektir. Güvenlik getirecektir çünkü uygulamanız DOS/DDOS gibi saldırılardan korunmuş olacaktır. Ölçeklendirilebilirlik getirecektir çünkü;

1 saatte 100 adet isteği 1 saniyede
karşılayan uygulama yine
1 saatte 1.000.000 isteği 1 saniyede
karşılayabilecektir.

İşte bu tutarlılık ölçeklendirilebilirliğin sonucudur. Eğer ki, DOS/DDOS saldırılarından herhangi biri gerçekleştirilirse uygulamadaki ölçeklendirilebilirlik bozulacak ve kimi kullanıcıya 1 saniyede dönen response’un bir diğerine dönmesi saniyeler ve hatta dakikalar sürebilecektir.

Rate Limit, API uygulamasına belirli bir süre zarfında ne kadar istek yapılabileceğini, hangi IP’lerin bundan muaf tutulabileceğini vs. belirleyebilmekte ve böylece uygulamamızın istek hacmini kontrol etmemizi sağlayabilmektedir. Bunun için bizlere IP Rate Limit ve Client ID Rate Limit olmak üzere iki farklı yaklaşım sunmaktadır.

IP Rate Limit Client ID Rate Limit
Belirtilen IP’ler dışından gelen tüm requestlere sınırlama getirir. Belirtilenleri bu sınırlamalardan muaf tutar.

Uygulamada static IP’ler varsa kesinlikle bu yaklaşım tercih edilmelidir.

Gelen request header bilgisinde belirli bir key – value değerine göre kontrol sağlar. Kontrol neticesinde eğer eşleşme varsa ilgili isteği yapan sınırlamadan muaf tutulur. Aksi taktirde tüm requestlere sınırlama getirilir.

Uygulamada static IP’ler yoksa bu yaklaşım kullanılabilir. Lakin dikkat edilmesi gereken husus şudur ki; kötü niyetli kişiler key – value değerlerini bir şekilde ifşa ederlerse uygulama tekrardan mevzu bahis saldırılara maruz kalabilir. O yüzden mümkün mertebe IP Rate Limit tercih edilmelidir.

Rate Limit Yapılanması ve Konfigürasyonu

Uygulamanızda Rate Limit konfigürasyonunu sağlayabilmek için custom bir middleware yazabilir ya da AspNetCoreRateLimit kütüphanesini kullanabilirsiniz. Bu kütüphane ile uygulamamızdaki Rate Limit konfigürasyonunun hepsini ‘appsettings.json’ dosyasından uygulayabilir ve rahatlıkla yönetebilirsiniz. Bizler de bu içeriğimizde ilgili kütüphane üzerinden seyredeceğiz…

İlk olarak örnek bir Asp.NET Core API uygulaması oluşturalım ve yapabileceğimiz sınırsız isteği fiilen inceleyelim…
Asp.NET Core - Rate Limit İle API Güvencesi Sağlama
Görüldüğü üzere rate limit’i belirtilmemiş bir uygulamaya kısa aralıkta elimizle manuel olacak bir şekilde onlarca defa istek gönderebilmekteyiz, gelin artık zararlı yazılımlarla bu isteğin ne kadar seri yapılabileceğini siz düşünün…

Artık bu bilgiler ışığında gelin API uygulamamıza nasıl rate limit’in uygunlandığını adım adım inceleyerek, görelim. Herşeyden önce yaklaşımdan bağımsız bir şekilde ilk olarak uygulamamıza ‘AspNetCoreRateLimit‘ kütüphanesini entegre ederek başlayalım.
Asp.NET Core - Rate Limit İle API Güvencesi Sağlama

Bu aşamadan sonra artık yaklaşım bazlı inceleme gerçekleştirebiliriz.

IP Rate Limit Yaklaşımı

Asp.NET Core uygulamasında IP bazlı Rate Limit uygulayabilmek için öncelikle ‘Startup.cs’ dosyasında aşağıdaki konfigürasyonların gerçekleştirilmesi gerekmektedir.

  1.             services.AddOptions();
    

    Rate Limit’e dair olan tüm konfigürasyonların ‘appsettings.json’ dosyasında tutulacağından dolayı buradaki yapılandırmayı öncelikle uygulamaya yüklememiz gerekmektedir.

  2.             services.AddMemoryCache();
    

    Süreçte yapılan istekler neticesinde limit durum bilgilerini cache’de tutmak için memory cache’i aktifleştiriyoruz.

  3.             services.Configure<IpRateLimitOptions>(Configuration.GetSection("IpRateLimiting"));
    

    ‘appsettings.json’ dosyasında tanımlanan genel konfigürasyon ayarlarını yüklüyoruz.

  4.             services.Configure<IpRateLimitPolicies>(Configuration.GetSection("IpRateLimitPolicies"));
    

    ‘appsettings.json’ dosyasında tanımlanmış IP kurallarını ve politikalarını yüklüyoruz.

  5.             services.AddSingleton<IIpPolicyStore, MemoryCacheIpPolicyStore>();
                services.AddSingleton<IRateLimitCounterStore, MemoryCacheRateLimitCounterStore>();
    

    Politika ve verilerin memory’de tutulacağını bildiriyoruz.

  6.             services.AddHttpContextAccessor();
    

    ClientId ve ClientIp çözümleri için kullanacağımız HttpContextAccessor servisini uygulamaya dahil ediyoruz.

  7.             services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
    

    Rate limit için tüm yapılanmaları organize bir şekilde inşa eden ana servisi ekliyoruz.

  8.             app.UseIpRateLimiting();
    

    Son olarakta ‘UseIpRateLimiting’ middleware’ini kullanarak Ip Rate Limit operasyonunu devreye sokuyoruz.

Nihai olarka ‘Startup.cs’ dosyasını aşağıdaki gibi inşa etmiş oluyoruz.

    public class Startup
    {
        IConfiguration Configuration;
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddOptions();
            services.AddMemoryCache();
            services.Configure<IpRateLimitOptions>(Configuration.GetSection("IpRateLimiting"));
            services.Configure<IpRateLimitPolicies>(Configuration.GetSection("IpRateLimitPolicies"));
            services.AddSingleton<IIpPolicyStore, MemoryCacheIpPolicyStore>();
            services.AddSingleton<IRateLimitCounterStore, MemoryCacheRateLimitCounterStore>();
            services.AddHttpContextAccessor();
            services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
            services.AddControllers();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
                app.UseDeveloperExceptionPage();
            app.UseIpRateLimiting();
            app.UseRouting();
            app.UseEndpoints(endpoints => endpoints.MapControllers());
        }
    }

Bu adımdan sonra artık ‘appsettings.json’ dosyasında aşağıdaki konfigürasyonlara geçebiliriz.

  "IpRateLimiting": {
    "EnableEndpointRateLimiting": true,
    "StackBlockedRequests": false,
    "HttpStatusCode": 429,
    "IpWhitelist": [ "127.0.0.12" ],
    "EndpointWhitelist": [ "*:/api/customers" ],
    "GeneralRules": [
      {
        "Endpoint": "*",
        "Period": "1s",
        "Limit": 2
      },
      {
        "Endpoint": "*:/api/products",
        "Period": "10s",
        "Limit": 5
      }
    ]
  }
  1. IpRateLimiting
    ‘Startup.cs’ dosyasında 3. adımda oluşturduğumuz ‘IpRateLimitOptions’ türünden konfigürasyona karşılık gelen alanı tarif etmektedir. Tüm rate limit ayarlamalarını bu değer içerisinde belirteceğiz.
  2. EnableEndpointRateLimiting
    Uygulamada endpoint seviyesinde rate limit uygulayabilmek için ‘true’ değerini veriyoruz. ‘false’ değerini verdiğiniz taktirde limitlerin hepsi global olarak uygulanacak ve endpointlerin hepsi için geçerli olacaktır.
  3. StackBlockedRequests
    Bu özelliğe bir misal ile yaklaşırsak daha doğru olacaktır. Varsayalım ki; uygulamanıza dakikada 60, saatte ise 1000 adet request gelebileceğini belirttiniz. Dakika içerisinde 60’ın üzerinde gelen requestlerin geçerli olup olmamasını işte bu ‘StackBlockedRequests’ özelliğiyle belirliyorsunuz. ‘true’ değerini verirseniz dakika sınırını aşan tüm requestler saat sınırında düşülecek aksi taktirde(false) dakika ve saat kendi sınırlarında değerlendirilecektir.
  4. HttpStatusCode
    Rate limit aşıldığı taktirde hangi tür durum kodu döndürüleceği belirtilmektedir. ‘429’ standart olarak rate limit hatasıdır.
  5. IpWhitelist
    Rate limitten muaf tutulacak IP adreslerini belirtiyoruz.
  6. EndpointWhitelist
    Rate limitten muaf tutulacak endpointleri belirtiyoruz. Burada http_function:/endpoint formatına dikkat etmenizi öneririm. Eğer ki herhangi bir HTTP fonksiyonu belirtilmeyecekse * ifadesi kullanılarak tümü ifade edilebilir.
  7. GeneralRules
    Genel rate limit kurallarını belirtiyoruz.

    İçerisinde ‘Endpoint’, ‘Period’ ve ‘Limit’ bilgilerini barındıran nesneler ile rate limit ayarları girilmekte ve istek hacmi belirtilmektedir. Her bir nesne bir HTTP isteğine uygun olarak tasarlanmaktadır.

    • ‘Endpoint’, rate limit uygulanacak endpointi ifade etmektedir. Aşağıdaki formatlardan herhangi birinde değer alabilmektedir;
      * : Tüm endpointlere karşılık gelmektedir.
      *:/api/products : /api/products endpointindeki herhangi bir HTTP türünden actiona karşılık gelmektedir.
      *:/api/products/* : İlgili endpointteki tüm actionlara karşılık gelmektedir.
    • ‘Period’, belirtilen rate limitin ne kadar süreliğine geçerli olduğunu tutmaktadır.
      s : Saniye
      m : Dakika
      h : Saat
    • ‘Limit’, rate limit değeridir.

    Yukarıda tanımlanan kuralları ele alırsak eğer;

          {
            "Endpoint": "*",
            "Period": "1s",
            "Limit": 2
          },
          {
            "Endpoint": "*:/api/products",
            "Period": "10s",
            "Limit": 5
          }
    

    Uygulamadaki tüm endpointlerin ‘1’ saniyede en fazla ‘2’ request alacağını ve ‘/api/products’ endpointine gönderilen tüm HTTP isteklerinde ise ’10’ saniyede ‘5’ request alacağını ifade etmektedir.

Tüm bu işlemlerden sonra ‘Program.cs’ dosyasında IP politikalarının aşağıdaki gibi seed edilmesi gerekmektedir.

        async public static Task Main(string[] args)
        {
            using IHost webHost = CreateHostBuilder(args).Build();
            IIpPolicyStore IpPolicy = webHost.Services.GetRequiredService<IIpPolicyStore>();
            await IpPolicy.SeedAsync();
            await webHost.RunAsync();
        }

Yapılan bu çalışmayı test edersek eğer;
Asp.NET Core - Rate Limit İle API Güvencesi Sağlama
Yandaki görseli incelerken yapılan istek neticesinde gelen header’a göz atarsanız eğer uygulanan kuralın periyoduna karşılık gelen ‘X-Rate-Limit-Limit’ değerini, kalan istek adedine karşılık gelen ‘X-Rate-Limit-Remaining’ değerini ve kuralın hangi tarihe kadar geçerli olduğunu ifade eden ‘X-Rate-Limit-Reset’ değerini göreceksiniz. Kuralda belirtilen istek hacmi aşıldığı taktirde ‘Retry-After’ değeri ile bir sonraki isteğin ne kadarlık bir periyot sonrasında yapılacağı da bildirilmektedir. Dolayısıyla belirtilen kurallar çerçevesinde uygulamaya gelen istekler bu şekilde sınırlandırılmakta ve güvenlik sağlanmaktadır.

RateLimitPolicies İle Genel Kuralları Geçersiz Kılmak
‘Startup.cs’ dosyasına 4. adımda eklediğimiz ‘IpRateLimitPolicies’ konfigürasyonuna karşılık özelleştirilmiş rate limit politikalarını aşağıdaki gibi tanımlayabilirsiniz.

  "IpRateLimitPolicies": {
    "IpRules": [
      {
        "Ip": "::1",
        "Rules": [
          {
            "Endpoint": "*",
            "Period": "10m",
            "Limit": 1500
          }
        ]
      },
      {
        "Ip": "192.168.24.25",
        "Rules": [
          {
            "Endpoint": "*:/api/products",
            "Period": "55s",
            "Limit": 21
          },
          {
            "Endpoint": "Get:/api/employees",
            "Period": "21h",
            "Limit": 100000
          }
        ]
      }
    ]
  }
  1. IpRateLimitPolicies
    Biraz önce bahsedildiği gibi ‘Startup.cs’de ‘IpRateLimitPolicies’ türüne karşılık oluşturulan konfigürasyondur.
  2. IpRules
    IP bazlı tanımlanacak olan kuralları içerisinde barındıran koleksiyondur. Nesnel olarak içerisinde oluşturulacak kurala ait ip değerini tutacak olan ‘Ip’ ve bu ip değerine ait kuralları taşıyacak olan ‘Rules’ özelliklerini barındıran nesneler tutmaktadır. Yukarıdaki örneği inceleyip misal olarak ‘192.168.24.25’ IP değerine sahip olan clientı ele alırsak eğer biri ‘prodocuts’ bir diğeri de ’employees’ olmak üzere iki endpointe’de istek geldiğinde sırasıyla ’55’ saniyede ’21’ istek, ’21’ saatte ise ‘100000’ istek yapabilecek bir hacme sahip olacağı belirtilmiştir.

‘appsettings.json’ dosyası içerisinde tanımlanan bu ‘IpRateLimiting’ ile ‘IpRateLimitPolicies’ konfigürasyonlarını bütünsel açıdan görebilmek için nihai içeriği komple aşağıya alalım.

  "IpRateLimiting": {
    "EnableEndpointRateLimiting": true,
    "StackBlockedRequests": false,
    "HttpStatusCode": 429,
    "IpWhitelist": [ "127.0.0.12" ],
    "EndpointWhitelist": [ "*:/api/customers" ],
    "GeneralRules": [
      {
        "Endpoint": "*",
        "Period": "1s",
        "Limit": 2
      },
      {
        "Endpoint": "*:/api/products",
        "Period": "10s",
        "Limit": 5
      }
    ]
  },
  "IpRateLimitPolicies": {
    "IpRules": [
      {
        "Ip": "::1",
        "Rules": [
          {
            "Endpoint": "*",
            "Period": "10m",
            "Limit": 1500
          }
        ]
      },
      {
        "Ip": "192.168.24.25",
        "Rules": [
          {
            "Endpoint": "*:/api/products",
            "Period": "55s",
            "Limit": 21
          },
          {
            "Endpoint": "Get:/api/employees",
            "Period": "21h",
            "Limit": 100000
          }
        ]
      }
    ]
  }

Rate limit konfigürasyonlarında özel ya da genel farketmeksizin kurallar açısından tümdengelimsel bir kontrol söz konusudur.

Limit Aşıldığında Verilecek Mesajları QuotaExceededResponse İle Özelleştirme
Bir endpointe yapılan istek neticesinde rate limit hacmi aşılıyorsa eğer aşağıdaki hatayı döndürecektir;

API calls quota exceeded! maximum admitted 2 per 3s.

Sizler isteğiniz doğrultusunda QuotaExceededResponse özelliği ile hataları özelleştirebilirsiniz. Bunun için ilgili özelliğin ‘IpRateLimiting’ alanı içerisinde aşağıdaki gibi tanımlanması yeterlidir.

    "QuotaExceededResponse": {
      "Content": "{{ \"message\": \"istek limiti asilmistir.\", \"details\": \"kota asildi. {1} basina {0} istek yapabilirsiniz. lutfen {2} saniye icerisinde tekrar deneyiniz.\" }}",
      "ContentType": "application/json",
      "StatusCode": 429
    }

Yukarıdaki kodu detaylandırırsak eğer;

  • Content
    Limit aşımı durumunda kullanıcıya verilecek olan mesajı barındıran özelliktir. Mesaj içerisinde süslü parantez ile yapılan bildiriler aşağıdaki özelliklere karşılık gelmektedir.
    {0} : Limit
    {1} : Periyot
    {2} : Kalan süre(Retry-After)
  • ContentType
    Mesajın formatını bildirmektedir.
  • StatusCode
    Hata kodunu 429 değeriyle rate limit aşımı olduğunu bildirmektedir.

Yapılan bu konfigürasyon neticesinde istek hacminin aşıldığı esnada aşağıdaki görseldeki gibi mesaj alınacaktır.
Asp.NET Core - Rate Limit İle API Güvencesi Sağlama

Evet… IP Rate Limit ile istek hacminin konfigürasyonunun nasıl gerçekleştirildiğini görmüş olduk. Şimdi sıra Client ID Rate Limit yapılanmasını incelemeye gelmiştir.

Client ID Rate Limit Yapılanması ve Konfigürasyonu

Client Id Rate Limit gerçekleştirebilmek için öncelikle ‘Startup.cs’ dosyasında aşağıdaki gibi konfigürasyonların gerçekleştirilmesi gerekmektedir.

    public class Startup
    {
        IConfiguration Configuration;
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddOptions();
            services.AddMemoryCache();
            services.Configure<ClientRateLimitOptions>(Configuration.GetSection("ClientRateLimiting"));
            services.Configure<ClientRateLimitPolicies>(Configuration.GetSection("ClientRateLimitPolicies"));
            services.AddSingleton<IClientPolicyStore, MemoryCacheClientPolicyStore>();
            services.AddSingleton<IRateLimitCounterStore, MemoryCacheRateLimitCounterStore>();
            services.AddHttpContextAccessor();
            services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
            services.AddControllers();
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
                app.UseDeveloperExceptionPage();
            app.UseClientRateLimiting();
            app.UseRouting();
            app.UseEndpoints(endpoints => endpoints.MapControllers());
        }
    }

Dikkat edilirse bu konfigürasyonların her biri ‘IP Rate Limit’in muadili olan ‘Client ID Rate Limit’ karşılıklarıdır.

Ayrıca ‘Program.cs’, içerisinde ip rate limit için yapılan konfigürasyonlar olmaksızın sade bir şekilde tasarlanmış olması gerekmektedir.

        async public static Task Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

Bu işlemlerden sonra ‘appsettings.json’ içeriğine gelirsek eğer;

  "ClientRateLimiting": {
    "EnableEndpointRateLimiting": true,
    "StackBlockedRequests": false,
    "HttpStatusCode": 429,
    "IpWhitelist": [ "127.0.0.12" ],
    "EndpointWhitelist": [ "*:/api/customers" ],
    "ClientIdHeader": "x-clientId",
    "ClientWhiteList": [ "client-1" ],
    "GeneralRules": [
      {
        "Endpoint": "*",
        "Period": "3s",
        "Limit": 2
      },
      {
        "Endpoint": "*:/api/products",
        "Period": "10s",
        "Limit": 5
      }
    ],
    "QuotaExceededResponse": {
      "Content": "{{ \"message\": \"istek limiti asilmistir.\", \"details\": \"kota asildi. {1} basina {0} istek yapabilirsiniz. lutfen {2} saniye icerisinde tekrar deneyiniz.\" }}",
      "ContentType": "application/json",
      "StatusCode": 429
    }
  },
  "ClientRateLimitPolicies": {
    "IpRules": [
      {
        "Ip": "::1",
        "Rules": [
          {
            "Endpoint": "*",
            "Period": "4s",
            "Limit": 3
          }
        ]
      },
      {
        "Ip": "192.168.24.25",
        "Rules": [
          {
            "Endpoint": "*:/api/products",
            "Period": "55s",
            "Limit": 21
          },
          {
            "Endpoint": "Get:/api/employees",
            "Period": "21h",
            "Limit": 100000
          }
        ]
      }
    ]
  }

şeklinde inşa edilmesi yeterlidir. Burada istek yapacak olan clientın; headerında, 7. satırdaki ‘ClientIdHeader’ alanındaki ‘x-clientId’ key’ine karşılık 8. satırdaki ‘ClientWhiteList’ alanındaki ‘client-1’ valuesu bulunduğu taktirde rate limit konfigürasyonlarından muaf tutulacağını aksi taktirde tüm isteklerde belirtilen sınırlılıkların uygulanacağını bildirmiş bulunmaktayız.

Asp.NET Core - Rate Limit İle API Güvencesi Sağlama

Evet… Görüldüğü üzere client, headerında konfigürasyondaki ilgili bilgilerle eşleşen key – value değerlerine sahip istek gönderdiği taktirde rate limitten muaf tutulmaktadır. Burada içeriğimizin ilk parafraflarında değindiğimiz bir duruma tekrardan temas etmemiz gerekirse eğer o da key – value değerlerinin kötü niyetli kullanıcılar tarafından elde edilmesi Client Id Rate Limit’e rağmen bir zaafiyet doğuracak ve neticede DOS/DDOS saldırılarıyla karşılaşma olası ihtimali artacaktır.

O yüzden static IP’lerin söz konusu olduğu tüm çalışmalarda IP Rate Limit yaklaşımının tercih edilmesini şiddetle tavsiye ederim…

Böylece Asp.NET Core WEB API uygulamalarında tüm açılarıyla Rate Limit konfigürasyonlarının nasıl gerçekleştirildiğini incelemiş olduk. Umarım sıkılmadan tüketirsiniz 🙂

İlgilenenlerin faydalanması dileğiyle…
Sonraki yazılarımda görüşmek üzere…
İyi çalışmalar…

Not : Örnek projeyi indirmek için buraya tıklayınız.

Bunlar da hoşunuza gidebilir...

3 Cevaplar

  1. Gençay dedi ki:

    Merhaba,

    Uygulama ayağa kaldırıldığında ‘appsettings.json’ dosyasında tanımlanan tüm limit kuralları kullanılan önbelleğe yüklenilecektir. Dolayısıyla runtime’da istenildiği taktirde bu önbellekteki kurallara eklemeler yapılabilir ve hatta kurallar veritabanında barındırılarak uygulama ayağa kaldırılırken sürece dahil edilebilir.

    Örnek kod için aşağıdaki yapılanmayı inceleyiniz;

        public class IpRateLimitController : ControllerBase
        {
            private readonly IpRateLimitOptions _options;
            private readonly IIpPolicyStore _ipPolicyStore;
    
            public IpRateLimitController(IOptions<IpRateLimitOptions> optionsAccessor, IIpPolicyStore ipPolicyStore)
            {
                _options = optionsAccessor.Value;
                _ipPolicyStore = ipPolicyStore;
            }
            [HttpGet]
            async public Task<IpRateLimitPolicies> Get()
            {
                return await _ipPolicyStore.GetAsync(_options.IpPolicyPrefix);
            }
    
            [HttpPost]
            async public void Post()
            {
                var pol = await _ipPolicyStore.GetAsync(_options.IpPolicyPrefix);
    
                pol.IpRules.Add(new IpRateLimitPolicy
                {
                    Ip = "::1",
                    Rules = new List<RateLimitRule>(new RateLimitRule[] {
                    new RateLimitRule {
                        Endpoint = "*",
                        Limit = 100,
                        Period = "1s" }
                })
                });
    
                await _ipPolicyStore.SetAsync(_options.IpPolicyPrefix, pol);
            }
        }
    

    Kolay gelsin.

  2. Kenan dedi ki:

    Çok yoğun bir saldırıda internet bant genişliğini sömürecektir ya da her talep mutlaka red/kabul şeklinde sunucuda işleneceği için işlemciyi tavan yaptıracaktır. Yine olması gereken bir korunma yöntemidir, tavsiye ederim.

Bir cevap yazın

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

*