La limitation de débit est une stratégie que vous pouvez utiliser pour contrôler le trafic sur un réseau. Il limite le nombre de demandes qu'un utilisateur peut faire dans un laps de temps spécifique.

Il existe divers algorithmes de limitation de débit, chacun avec ses propres compromis. Une méthode simple et populaire consiste à suivre les adresses IP des demandes et à vérifier le temps qui s'écoule entre les demandes. Le système peut alors refuser une requête si son adresse IP dépasse le nombre de requêtes autorisées par la limite.

Cette approche de la limitation du débit est facile à intégrer dans une application NodeJS-Express, en quelques étapes seulement.

Étape 1: Configurer un environnement de développement

Tout d'abord, vous devrez créer et initialiser une application Express.

Commencez par créer un répertoire de projet en exécutant :

application express mkdir

Entrez ensuite dans ce répertoire en exécutant :

CD application express

Ensuite, initialisez npm, le gestionnaire de packages de nœuds, et créer un package.json fichier dans votre application en exécutant :

instagram viewer 
npm init -y

La -y flag créera votre package.json fichier avec tous les paramètres par défaut.

Ensuite, vous devrez installer certaines dépendances. Les dépendances requises pour ce tutoriel sont :

  • ExpressJS: ExpressJS est un framework NodeJS qui fournit un ensemble robuste de fonctionnalités pour les applications Web et mobiles. Il simplifie le processus de création d'applications backend avec NodeJS.
  • Limite de débit express: Express rate limit est un middleware de limitation de débit pour ExpressJS. Il limite les demandes répétées aux API publiques et/ou aux points de terminaison, telles que les réinitialisations de mot de passe, les connexions des utilisateurs, etc.

Installez les dépendances requises en exécutant :

npm installer express express-tarif-limite

Étape 2: Création d'une application express

Vous devrez créer un serveur Express de base qui écoute les requêtes adressées à votre application.

Tout d'abord, créez un index.js fichier dans le répertoire racine de votre projet. Ce sera le dossier d'entrée de votre candidature.

Ensuite, ajoutez le code suivant à votre index.js dossier:

// index.js
constante exprimer = exiger("Express");
constante app = express();
constante port = processus.env. PORT || 3000
app.listen (port, () => {
console.Journal(`Application en cours d'exécution sur le port ${port}`);
});

Ce code importe Express et crée une application Express en appelant express() et en stockant sa valeur de retour dans le application variable. Il écoute ensuite le trafic sur le port 3000 en appelant le Ecoutez méthode sur la application objet.

Étape 3: Création de gestionnaires de routage

Ensuite, créez des gestionnaires de route sur lesquels vous pouvez implémenter la solution de limitation de débit.

Commencez par créer un dossier, routes, dans le répertoire racine de votre projet en exécutant :

itinéraires mkdir

Créer un dossier, routes.js, dans votre dossier routes et ajoutez le code suivant :

constante exprimer = exiger("Express");
constante routeur = express. Routeur();
routeur.get("/", (req, res) => {
 res.send({ message: "Bonjour, ceci est une requête GET" });
});


routeur.post("/add-demo", (req, res) => {
 res.status (201).send({ message: "Ressource créée avec succès" });
});


router.put("/update-demo", (req, res) => {
 res.status (201).send({ message: "Ressource mise à jour avec succès" });
});
module.exportations = routeur ;

Ce code importe Express, appelle le Routeur méthode sur Express, et stocke la valeur dans une variable, routeur. La Routeur vous permet de créer des gestionnaires de routage modulaires et montables. Vous pouvez créer des gestionnaires de route pour un OBTENIR demande à "/", un PUBLIER demande à "/add-demo», et un METTRE demande à "/update-demo”. Enfin, exportez le routeur variable.

Ensuite, importez le routeur variables dans votre index.js dossier:

// index.js
constante itinéraires = exiger(""./routes/routes");

Ensuite, utilisez-le comme middleware dans votre fichier index.js :

// index.js
application.utilisation(itinéraires);

Assurez-vous de placer le bloc de code ci-dessus avant le app.écouter appel.

Étape 4: mise en œuvre de la limitation de débit

Tout d'abord, créez un "middleware" dans le répertoire racine de votre projet en exécutant :

middleware mkdir

Créez ensuite un fichier appelé "rate-limiter.js” dans le répertoire middleware. Ajoutez le code suivant à ce fichier :

// rate-limiter.js
constante rateLimiter = exiger("express-rate-limit");
constante limiteur = rateLimiter({
 maximum: 5,
 fenêtreMS: 10000, // 10 secondes
 message: "Tu peux'Je ne fais plus de demandes pour le moment. Réessayez plus tard",
});
module.exportations = limiteur

La rateLimiter La fonction prend un objet de configuration avec les conditions pour limiter le nombre de requêtes.

Les propriétés de l'objet de configuration ci-dessus sont :

  • maximum: Cette propriété doit toujours être un Numéro ou une fonction qui renvoie un nombre. Il représente le nombre maximum de requêtes qu'un utilisateur peut effectuer dans un délai spécifié. Si cette propriété n'est pas définie dans l'objet de configuration, sa valeur par défaut est 5.
  • windowsMS: Cette propriété doit toujours être un nombre. Il représente le délai dans lequel plusieurs demandes sont autorisées dans millisecondes. Si cette propriété n'est pas définie dans l'objet de configuration, sa valeur par défaut est de 60 000 millisecondes (une minute).
  • message: Cette propriété peut être un chaîne de caractères, un objet JSON ou toute autre valeur prise en charge par Réponse d'Express.send méthode. Si cette propriété n'est pas définie dans l'objet de configuration, sa valeur par défaut est « Trop de requêtes. Veuillez réessayer plus tard."

La fonction vérifiera ensuite les demandes répétées à votre application. Si un utilisateur dépasse la limite (maximum, 5) dans les délais (fenêtreMS, 10s), il bloquera la requête. Il lancera également une erreur "Too Many Requests" avec un code d'état de 429.

Enfin, importez la fonction limiteur dans votre index.js fichier et appliquez-le en tant que middleware global dans votre application. Faites cela en plaçant app.use (limiteur) au-dessus du middleware des routes. Cela applique la solution de limitation de débit à toutes les routes de votre application.

application.utilisation(limiteur);

Routes spécifiques à limitation de débit

Vous pouvez également appliquer une limitation de débit à des itinéraires spécifiques. Vous pouvez les configurer séparément pour rejeter les demandes effectuées dans un délai différent, afficher un message différent, etc.

Par exemple, supposons que vous implémentiez un itinéraire de connexion utilisateur dans votre application. Vous devrez peut-être ajouter une configuration de limitation de débit pour la route de connexion qui diffère de la configuration utilisée par les autres routes.

Tout d'abord, vous devrez supprimer limiteur en tant que middleware au niveau de l'application et appliquez-le car il n'y a pas de système de filtrage de middleware intégré dans ExpressJS. Ainsi, même si vous ajoutez une solution de limitation de débit spécifique à une route, le middleware global fonctionnera toujours sur cette route.

Ensuite, créez une nouvelle configuration de limitation de débit dans votre rate-limiter.js fichier et exportez-le.

constante signInLimiter = rateLimiter({
 maxi: 3,
 fenêtreMS: 10000, //10 secondes
 message: "Trop de tentatives de connexion. Réessayez plus tard."
})
module.exportations = {
 limiteur,
 signInLimiter
}

La signInLimiter l'objet de configuration a un nombre différent de maximum requêtes et un message d'erreur différent du limiteur de débit général.

Enfin, mettez à jour votre routeur.js fichier avec le bloc de code ci-dessous :

// routeur.js
constante exprimer = exiger("Express");
constante routeur = express. Routeur();
constante {limiteur, signInLimiter} = exiger("../middleware/rate-limiter")
routeur.get("/sign-in", signInLimiter, (req, res, suivant) => {
 res.send({ message: "Bonjour, ceci est une requête GET" });
});


routeur.utilisation(limiteur)


routeur.post("/post", (req, res) => {
 res.status (201).send({ message: "Ressource créée avec succès" });
});


router.put("/put", (req, res) => {
 res.status (201).send({ message: "Ressource mise à jour avec succès" });
});
module.exportations = routeur ;

Dans le bloc de code ci-dessus, vous avez importé limiteur et signInLimiter. Ensuite, vous avez postulé signInLimiter comme un limiteur de débit spécifique au «/sign-in" itinéraire.

Enfin, en plaçant router.use (limiteur) au-dessus du reste des itinéraires, vous avez appliqué le limiteur comme limiteur de débit pour le reste des itinéraires.

L'importance de la limitation de débit

La limitation du débit réduit la charge sur votre serveur Web en évitant d'avoir à traiter trop de requêtes à la fois. Il réduit l'activité des bots, vous protège des attaques par déni de service (DoS) et empêche les attaques par force brute.