A developer working in a modern workspace with abstract cues of API traffic control on a monitor. AI-generated editorial image.
Lorsqu’une API reçoit plus de trafic qu’elle ne peut en traiter confortablement, le problème n’est pas seulement la performance. Il touche aussi à l’équité, à la stabilité et au contrôle des coûts. Le rate limiting des API aide à fixer des limites prévisibles afin qu’un client, un utilisateur ou une intégration ne consomme pas toute la capacité disponible.
L’objectif n’est pas de pénaliser l’usage légitime. Il s’agit de rendre le service compréhensible sous charge. Une bonne limite indique ce qu’un client peut attendre, donne aux développeurs un mode d’échec clair et protège le reste du système contre un voisin bruyant ou une boucle accidentelle.
Ce que le rate limiting cherche à résoudre
Le rate limiting contrôle le nombre de requêtes qu’un appelant peut effectuer sur une période donnée. Cette période peut être d’une seconde, d’une minute ou d’un autre intervalle adapté à votre charge. La politique exacte dépend du produit, mais les raisons de fond sont souvent les mêmes :
- éviter qu’un pic accidentel ne surcharge une base de données ou un service aval
- réduire l’impact des abus, du scraping ou des tentatives répétées
- préserver un service prévisible pour les autres utilisateurs
- laisser de la place à des politiques de trafic différentes pour l’interne ou les offres premium si nécessaire
Le rate limiting est différent de l’authentification. L’authentification répond à la question qui êtes-vous. Le rate limiting répond à la question combien pouvez-vous faire maintenant. Les deux sont utiles, mais ils ne résolvent pas le même problème.
Choisir une stratégie avant d’écrire le code
Il n’existe pas un seul algorithme idéal. Le bon choix dépend du niveau de rigueur attendu et de la fluidité d’usage souhaitée.

Fenêtre fixe
C’est le modèle le plus simple : autoriser un certain nombre de requêtes par fenêtre de temps. Par exemple, un appelant peut faire 100 requêtes par minute. C’est facile à comprendre et à mettre en œuvre, mais cela peut créer des pics aux frontières entre deux fenêtres.
Fenêtre glissante
Une fenêtre glissante compte les requêtes sur un intervalle mobile. Elle est souvent plus équitable qu’une fenêtre fixe, car elle lisse les pics de bordure, mais elle est plus complexe à implémenter et peut demander davantage de stockage ou de calcul.
Token bucket
Le modèle token bucket est courant quand on veut accepter des rafales courtes tout en gardant une moyenne stable. Les jetons s’accumulent avec le temps jusqu’à une limite maximale. Chaque requête consomme un jeton. C’est un bon compromis quand les rafales brèves sont acceptables mais qu’une surcharge prolongée ne l’est pas.
Leaky bucket
Le modèle leaky bucket lisse le trafic en traitant les requêtes à un rythme constant. Il peut être adapté lorsque les systèmes aval préfèrent un flux régulier, mais il peut sembler moins flexible pour les clients qui ont besoin de petites rafales.
Si vous hésitez, le token bucket est souvent un point de départ pratique pour une API publique, car il équilibre équité et facilité d’usage. Cela dit, la meilleure option dépend de ce que vous voulez protéger et de la tolérance de vos clients aux rafales.
Une approche simple d’implémentation dans ASP.NET Core
Dans ASP.NET Core, un limiteur peut être placé tôt dans la chaîne de traitement afin d’éviter du travail coûteux lorsqu’une requête est déjà hors quota. L’exemple ci-dessous montre la forme d’une politique token bucket avec le patron de middleware de rate limiting intégré. Considérez-le comme une configuration illustrative, pas comme un modèle prêt à copier tel quel en production.

using System.Threading.RateLimiting;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddRateLimiter(options =>
{
options.AddTokenBucketLimiter("api", limiterOptions =>
{
limiterOptions.TokenLimit = 100;
limiterOptions.TokensPerPeriod = 20;
limiterOptions.ReplenishmentPeriod = TimeSpan.FromSeconds(1);
limiterOptions.QueueLimit = 0;
limiterOptions.AutoReplenishment = true;
});
});
var app = builder.Build();
app.UseRateLimiter();
app.MapGet("/api/data", () => Results.Ok(new { message = "ok" }))
.RequireRateLimiting("api");
app.Run();Ce modèle met en évidence les éléments principaux :
- TokenLimit définit le plafond de rafale.
- TokensPerPeriod et ReplenishmentPeriod déterminent le débit moyen autorisé.
- QueueLimit contrôle si les requêtes excédentaires attendent ou échouent immédiatement.
Si votre application sert des utilisateurs interactifs, une petite file peut améliorer la perception de réactivité. Si elle sert des clients machine ou si vous voulez un rejet très prévisible sous charge, un échec rapide est souvent plus simple à gérer.
Où appliquer les limites et sur quoi les baser
Tous les endpoints ne devraient pas partager la même limite. Les endpoints de connexion, les recherches coûteuses, les envois de fichiers et les endpoints publics en lecture ont souvent besoin de politiques différentes. Une limite globale unique est plus simple, mais elle peut donner de mauvais résultats lorsqu’un chemin très sollicité domine le trafic.
Les critères de limitation courants sont :
- par adresse IP pour le trafic anonyme, avec prudence derrière des proxys et des réseaux partagés
- par utilisateur authentifié lorsque l’identité est fiable
- par clé API ou identifiant client pour les intégrations et partenaires
- par route lorsque certaines opérations sont plus coûteuses
Faites attention aux limites basées sur l’IP derrière un équilibreur de charge ou un reverse proxy. Si l’application ne connaît pas correctement l’adresse d’origine, elle peut traiter plusieurs utilisateurs comme un seul, ou ne pas les distinguer comme prévu. Utilisez les métadonnées réellement fournies par votre environnement d’hébergement et configurez la frontière de confiance de manière volontaire.
Concevoir la réponse d’échec, pas seulement la limite
Une limite n’est utile que si les clients peuvent y réagir. Un bon mode d’échec est explicite et cohérent. La pratique courante consiste à renvoyer un code 429 lorsque l’appelant a dépassé le débit autorisé. Vous pouvez aussi inclure des en-têtes qui aident le client à comprendre quand réessayer, selon la conception de votre API.
Une limite utile est une limite que les clients peuvent prévoir et gérer proprement. Un timeout mystérieux est souvent plus difficile à diagnostiquer qu’un rejet explicite.
Assurez-vous que votre payload d’erreur reste stable et lisible. Par exemple, la réponse peut expliquer que le débit de requêtes est trop élevé et suggérer de réessayer plus tard. N’exposez pas de compteurs internes ni de détails d’implémentation sauf s’ils font volontairement partie du contrat public.
Checklist de vérification et erreurs fréquentes
Après l’implémentation, vérifiez le comportement dans les cas normaux et limites. L’objectif est d’obtenir des réponses prévisibles, pas seulement l’absence d’exception.
- Vérifiez qu’un même appelant atteint la limite configurée puis reçoit le rejet attendu.
- Contrôlez que la limite se réinitialise ou se recharge selon la politique choisie.
- Testez une rafale de requêtes pour voir si les requêtes en file attendent ou échouent comme prévu.
- Vérifiez que différents endpoints peuvent utiliser des politiques différentes si vous les avez configurées ainsi.
- Contrôlez le comportement de l’application derrière votre proxy ou votre load balancer.
Les erreurs fréquentes consistent à fixer une limite trop basse, à oublier de séparer les endpoints coûteux et à s’appuyer sur l’IP sans comprendre le chemin réseau. Un autre problème courant est de placer le limiteur trop tard dans la pipeline, après qu’une partie du travail a déjà été effectuée.
Le rate limiting ne remplace pas le cache, l’optimisation des requêtes ni la détection d’abus. C’est une couche de contrôle parmi d’autres. Si une requête est coûteuse, il reste utile de la rendre moins chère quand c’est possible.
Pour les équipes qui construisent une API ou l’intègrent dans un produit, une politique de rate limiting claire peut éviter bien des frictions. Si vous souhaitez revoir plus largement la manière dont votre service expose et protège ses endpoints, la page des services de développement web, d’applications et de logiciels présente les domaines publiés d’Octobytes.
Prochaine étape : choisissez un endpoint très sollicité, décidez ce qu’il doit protéger, puis notez la clé de limitation, la fenêtre, la réponse de rejet et le comportement de retry avant de l’implémenter.
