La meilleure façon d'implémenter la limitation des demandes dans ASP.NET MVC?

Nous expérimentons différentes façons de limiter les actions des utilisateurs au cours d'une période donnée :

• Limiter les messages de questions / réponses
• Limiter les modifications
• Limiter les récupérations de flux

Pour le moment, nous utilisons le cache pour simplement insérer un enregistrement de l'activité de l'utilisateur - si cet enregistrement existe si / quand l'utilisateur fait la même activité, nous étranglons.

L'utilisation du cache nous permet automatiquement de nettoyer les données périmées et de faire glisser les fenêtres d'activité des utilisateurs, mais la façon dont il évoluera pourrait être un problème.

Quels sont les autres moyens de garantir que les requêtes / actions des utilisateurs peuvent être efficacement limitées (accent mis sur la stabilité)?

Voici une version générique de ce que nous utilisons sur Stack Overflow depuis un an:

/// <summary>
/// Decorates any MVC route that needs to have client requests limited by time.
/// </summary>
/// <remarks>
/// Uses the current System.Web.Caching.Cache to store each client request to the decorated route.
/// </remarks>
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class ThrottleAttribute : ActionFilterAttribute
{
    /// <summary>
    /// A unique name for this Throttle.
    /// </summary>
    /// <remarks>
    /// We'll be inserting a Cache record based on this name and client IP, e.g. "Name-192.168.0.1"
    /// </remarks>
    public string Name { get; set; }

    /// <summary>
    /// The number of seconds clients must wait before executing this decorated route again.
    /// </summary>
    public int Seconds { get; set; }

    /// <summary>
    /// A text message that will be sent to the client upon throttling.  You can include the token {n} to
    /// show this.Seconds in the message, e.g. "Wait {n} seconds before trying again".
    /// </summary>
    public string Message { get; set; }

    public override void OnActionExecuting(ActionExecutingContext c)
    {
        var key = string.Concat(Name, "-", c.HttpContext.Request.UserHostAddress);
        var allowExecute = false;

        if (HttpRuntime.Cache[key] == null)
        {
            HttpRuntime.Cache.Add(key,
                true, // is this the smallest data we can have?
                null, // no dependencies
                DateTime.Now.AddSeconds(Seconds), // absolute expiration
                Cache.NoSlidingExpiration,
                CacheItemPriority.Low,
                null); // no callback

            allowExecute = true;
        }

        if (!allowExecute)
        {
            if (String.IsNullOrEmpty(Message))
                Message = "You may only perform this action every {n} seconds.";

            c.Result = new ContentResult { Content = Message.Replace("{n}", Seconds.ToString()) };
            // see 409 - http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html
            c.HttpContext.Response.StatusCode = (int)HttpStatusCode.Conflict;
        }
    }
}

Exemple d'utilisation:

[Throttle(Name="TestThrottle", Message = "You must wait {n} seconds before accessing this url again.", Seconds = 5)]
public ActionResult TestThrottle()
{
    return Content("TestThrottle executed");
}

Le cache ASP.NET fonctionne comme un champion ici - en l'utilisant, vous obtenez un nettoyage automatique de vos entrées d'accélérateur. Et avec notre trafic croissant, nous ne voyons pas que c'est un problème sur le serveur.

N'hésitez pas à donner votre avis sur cette méthode; lorsque nous améliorons Stack Overflow, vous obtenez votre correctif Ewok encore plus rapidement :)

Microsoft a une nouvelle extension pour IIS 7 appelée extension des restrictions IP dynamiques pour IIS 7.0 - Beta.

«Les restrictions IP dynamiques pour IIS 7.0 est un module qui fournit une protection contre le déni de service et les attaques par force brute sur le serveur Web et les sites Web. Cette protection est fournie en bloquant temporairement les adresses IP des clients HTTP qui effectuent un nombre inhabituellement élevé de demandes simultanées ou qui font un grand nombre de demandes sur une courte période. " http://learn.iis.net/page.aspx/548/using-dynamic-ip-restrictions/

Exemple:

Si vous définissez les critères de blocage après X requests in Y millisecondsou si X concurrent connections in Y millisecondsl'adresse IP sera bloquée, les Y millisecondsdemandes seront à nouveau autorisées.

Nous utilisons la technique empruntée à cette URL http://www.codeproject.com/KB/aspnet/10ASPNetPerformance.aspx , non pas pour la limitation, mais pour le déni de service (DOS) d'un pauvre. Ceci est également basé sur le cache et peut être similaire à ce que vous faites. Étrangez-vous pour empêcher les attaques DOS? Les routeurs peuvent certainement être utilisés pour réduire le DOS; pensez-vous qu'un routeur pourrait gérer la limitation dont vous avez besoin?