Redis, également appelé Remote Dictionary Server, est une base de données en mémoire open-source. Il s'agit d'un système de stockage de structures de données qui s'exécute sur la mémoire RAM d’un serveur, ce qui est beaucoup plus rapide que le plus rapide des disques SSD (SSD). En conséquence, Redis est très réactif et convient parfaitement à la limitation de débit.
La limitation de débit restreint le nombre de fois qu’un utilisateur peut demander une ressource à un serveur. De nombreux services utilisent des limites de débit pour empêcher l’abus de service, comme lorsqu’un utilisateur tente de surcharger un serveur avec une charge trop importante. Par exemple, lors de l’utilisation de PHP pour développer une API (Application Programming Interface) publique pour votre application web, des restrictions de débit sont nécessaires. C’est parce que lorsque vous exposez une API au public, vous voudrez limiter le nombre de fois qu’un individu peut répéter une activité dans un certain laps de temps. Les utilisateurs qui n’ont aucune autorité sur votre système peuvent le paralyser.
La limitation de débit permet à votre application de fonctionner de manière fluide en rejetant les requêtes des utilisateurs qui dépassent une limite définie. Si vous avez un grand nombre de clients, la limitation de débit impose une politique d’utilisation équitable qui permet à chaque utilisateur d’accéder à votre application à des vitesses rapides. La limitation de débit peut également vous aider à économiser de l’argent sur la bande passante en réduisant la congestion sur votre serveur.
En suivant l’activité des utilisateurs dans une base de données comme MySQL, il serait possible de créer un programme de limitation de débit. Cependant, comme ces données doivent être téléchargées depuis le disque et évaluées par rapport à la limite définie, le résultat final peut ne pas être évolutif lorsque plusieurs personnes contactent le système. Non seulement cela est inefficace, mais les solutions de gestion de bases de données relationnelles n’ont pas été conçues pour cela.
Redis est un bon choix pour créer un limiteur de débit car il fonctionne comme une base de données en mémoire et a été prouvé comme étant fiable pour cela. Dans ce tutoriel, nous vous guiderons à travers les étapes de la mise en œuvre de la limitation de débit PHP à l’aide de Redis sur Ubuntu 20.04.
Commençons !
Prérequis
Pour suivre ce tutoriel, vous aurez besoin de ce qui suit :
-
La dernière version d’Ubuntu installée sur votre système.
-
Les utilisateurs du système doivent disposer des privilèges sudo.
-
Une pile LAMP.
-
Configurez-la en suivant le tutoriel Comment configurer la pile LAMP.
-
-
Un serveur Redis.
-
Suivez le guide Comment installer et sécuriser le serveur Redis pour configurer Redis sur votre système.
-
Étape 1 : Installer l’extension Redis pour PHP
Avant de commencer, mettons à jour les dépôts pour éviter les conflits de paquets :
|
1 |
sudo apt update |
Ensuite, installez l’extension php-redis, un paquet qui permet d’utiliser Redis dans les programmes PHP. Exécutez la commande sudo suivante pour installer php-redis:
|
1 |
sudo apt install -y php-redis |
Après cela, redémarrez le serveur Apache pour charger la bibliothèque php-redis :
|
1 |
sudo systemctl restart apache2 |
L’étape suivante consiste à mettre à jour les informations de votre index de logiciels et à installer la bibliothèque Redis pour PHP. Ensuite, nous créerons une ressource PHP qui restreint l’accès en fonction de l’adresse IP de l’utilisateur.
Étape 2 : Créer une ressource web PHP pour la limitation de débit
Dans cette étape, vous créerez un fichier demo.php dans le répertoire racine de votre serveur web ( /var/www/html/). Ce fichier sera ouvert au public, et les utilisateurs pourront lancer l’URL dans leur navigateur web préféré. Plus tard, nous utiliserons la commande curl pour vérifier l’accessibilité de la ressource que nous voulons utiliser. Les utilisateurs peuvent accéder au fichier de ressource d’exemple trois fois dans un intervalle de 15 secondes. Une tentative dépassant la limite maximale affichera un message d’erreur.
La fonctionnalité principale de ce fichier dépend fortement du serveur Redis. Le code PHP dans le fichier crée une clé sur le serveur Redis en fonction de l’adresse IP de l’utilisateur lorsque celui-ci accède à la ressource pour la première fois. Le code tentera de faire correspondre l’adresse IP de l’utilisateur avec les clés enregistrées dans le serveur Redis et augmentera la valeur de un si la clé existe lorsque l’utilisateur revient sur la ressource. Le code PHP continuera à vérifier si la nouvelle valeur a atteint le montant maximum.
Après 15 secondes, la clé Redis, qui est basée sur l’adresse IP de l’utilisateur, expirera, et le suivi des visites de l’utilisateur sur la ressource web recommencera. Ouvrez le /var/www/html/demo.php fichier dans l’éditeur de texte nano :
|
1 |
sudo nano /var/www/html/demo.php |
Ensuite, renseignez tous les champs pour initialiser la classe Redis. N’oubliez pas de définir le REDIS_PASSWORD sur la valeur correcte :
|
1 2 3 4 |
<?php $redis = new Redis(); $redis->connect('127.0.0.1', 6379); $redis->auth('REDIS_PASSWORD'); |
Redis->auth prend en charge l’authentification en texte brut du serveur Redis. Cela fonctionne bien si vous travaillez localement (via localhost), mais si vous avez affaire à un serveur Redis distant, l’authentification SSL est recommandée.
Ensuite, dans le même fichier, définissez les variables suivantes sur leurs valeurs par défaut :
|
1 2 3 4 5 |
. . . $max_calls_limit = 3; $time_period = 15; $total_user_calls = 0; |
Comprenons ces instructions en détail :
-
$max_calls_limit : Un utilisateur ne peut pas accéder à la ressource au-delà de cette limite maximale d’appels.
-
$time_period : Ceci est utilisé comme intervalle de temps et est compté en secondes. Ici, l’utilisateur est autorisé à accéder à la ressource selon les limites définies dans le $max_calls_limit .
-
$total_user_calls : Additionne le nombre de fois qu’un utilisateur a demandé l’accès à la limite d’ appels dans une période de temps donnée.
Ensuite, ajoutez le code suivant pour obtenir l’adresse IP de l’utilisateur demandant à accéder à la page web :
|
1 2 3 4 5 6 7 8 9 10 |
. . . if (!empty($_SERVER['HTTP_CLIENT_IP'])) { $user_ip_address = $_SERVER['HTTP_CLIENT_IP']; } elseif(!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) { $user_ip_address = $_SERVER['HTTP_X_FORWARDED_FOR']; } else { $user_ip_address = $_SERVER['REMOTE_ADDR']; } |
À titre de démonstration, ce code enregistre les actions des utilisateurs par leurs adresses IP. Si vous disposez d’une ressource protégée sur le serveur qui nécessite une authentification, vous pouvez suivre les actions des utilisateurs à l’aide de leurs noms d’utilisateur ou de leurs jetons d’accès.
Dans notre guide, chaque utilisateur qui se connecte à votre système se verra attribuer un identifiant unique (par exemple, un ID client, un ID développeur, un ID fournisseur ou même un ID utilisateur). N’oubliez pas d’utiliser ces ID au lieu de l’ $user_ip de l’utilisateur si vous suivez notre tutoriel.
Ici, l’adresse IP de l’utilisateur suffit à démontrer le concept. Ajoutez le bloc de code suivant à votre fichier une fois que vous avez obtenu l’adresse IP de l’utilisateur à partir de l’extrait de code précédent :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
. . . if (!$redis->exists($user_ip_address)) { $redis->set($user_ip_address, 1); $redis->expire($user_ip_address, $time_period); $total_user_calls = 1; } else { $redis->INCR($user_ip_address); $total_user_calls = $redis->get($user_ip_address); if ($total_user_calls > $max_calls_limit) { echo "L’utilisateur " . $user_ip_address . " a dépassé la limite."; exit(); } } echo "Bienvenue " . $user_ip_address . ", total des appels effectués : " . $total_user_calls . " en " . $time_period . " secondes"; |
Voici un aperçu de ces instructions :
-
if...else: L’instruction vérifie s’il existe une clé définie avec l’adresse IP sur le serveur Redis.
-
Si la clé n’est pas trouvée, si (!$redis->exists($user_ip_address)) {...}, vous pouvez définir la clé et définir sa valeur sur 1 en utilisant $redis->set($user_ip_address, 1).
-
-
$redis->expire($user_ip_address, $time_period): Indique à la clé d’expirer à un moment spécifié. Ici, dans ce tutoriel, nous l’avons définie sur 15 secondes.
-
Si l’adresse IP de l’utilisateur n’est pas trouvée dans la clé Redis, définissez la variable $total_user_calls valeur comme 1.
-
else {...}: Le bloc d’instructions utilise la commande $redis->INCR($user_ip_address); pour incrémenter la valeur de la clé Redis de 1. Cela sera appliqué à chaque adresse IP alignée avec la clé.
-
Note: Vous ne pouvez y parvenir que lorsque la clé est déjà définie dans le serveur Redis et comptabilisée comme une requête répétitive.
-
-
$total_user_calls = $redis->get($user_ip_address): Cette instruction récupère le total des requêtes en vérifiant leur clé respective basée sur l’adresse IP sur le serveur Redis.
-
if ($total_user_calls > $max_calls_limit) {... }..: Cette if instruction est utilisée pour vérifier si la limite est dépassée. Si oui, vous informez l’utilisateur avec echo "Utilisateur" . $user_ip_address . " limite dépassée.";.
Enfin, vous informez l’utilisateur de son nombre de visites au cours d’une période spécifiée en utilisant l’instruction echo "Bienvenue" . $user_ip_address . "appels totaux effectués" . $total_user_calls . "en" . $time_period . "secondes"; .
Après cela, ajoutez les lignes de code suivantes dans votre fichier /var/www/html/demo.php :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
<?php $redis = new Redis(); $redis->connect('127.0.0.1', 6379); $redis->auth('REDIS_PASSWORD'); $max_calls_limit = 3; $time_period = 15; $total_user_calls = 0; if (!empty($_SERVER['HTTP_CLIENT_IP'])) { $user_ip_address = $_SERVER['HTTP_CLIENT_IP']; }elseif (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) { $user_ip_address = $_SERVER['HTTP_X_FORWARDED_FOR']; } else { $user_ip_address = $_SERVER['REMOTE_ADDR']; } if (!$redis->exists($user_ip_address)) { $redis->set($user_ip_address, 1); $redis->expire($user_ip_address, $time_period); $total_user_calls = 1; } else { $redis->INCR($user_ip_address); $total_user_calls = $redis->get($user_ip_address); if ($total_user_calls > $max_calls_limit) { echo "Utilisateur " . $user_ip_address . " limite dépassée."; exit(); } } echo "Bienvenue " . $user_ip_address . " total des appels passés " . $total_user_calls . " en " . $time_period . " secondes"; ?> |
Enregistrez et fermez le fichier /var/www/html/demo.php après l’avoir modifié. Sur la page web demo.php, vous avez maintenant créé la logique requise pour limiter le débit des utilisateurs. Testons notre script à l’étape suivante.
Étape 3 : Exécuter le test de limitation de débit Redis
Vous utiliserez la commande curl dans cette étape pour demander la ressource web que vous avez écrite à l’Étape 2. Pour tester le script en profondeur, émettez une seule commande qui demande la ressource cinq fois. Cela peut être accompli en ajoutant un argument d’URL d’espace réservé à demo.php fin du fichier. Pour exécuter les curl instructions cinq fois, utilisez la valeur ?[1-5] à la fin de votre requête.
Exécutez la commande curl suivante ci-dessous :
|
1 |
curl -H "Accept: text/plain" -H "Content-Type: text/plain" -X GET http://localhost/demo.php?[1-5] |
Lorsque vous exécutez le code, vous devriez obtenir quelque chose comme ceci :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
[1/5]: http://localhost/demo.php?1 --> <stdout> --_curl_--http://localhost/demo.php?1 Bienvenue 127.0.0.1 total des appels effectués 1 en 15 secondes [2/5]: http://localhost/demo.php?2 --> <stdout> --_curl_--http://localhost/demo.php?2 Bienvenue 127.0.0.1 total des appels effectués 2 en 15 secondes [3/5]: http://localhost/demo.php?3 --> <stdout> --_curl_--http://localhost/demo.php?3 Bienvenue 127.0.0.1 total des appels effectués 3 en 15 secondes [4/5]: http://localhost/demo.php?4 --> <stdout> --_curl_--http://localhost/demo.php?4 Utilisateur 127.0.0.1 limite dépassée. [5/5]: http://localhost/demo.php?5 --> <stdout> --_curl_--http://localhost/demo.php?5 Utilisateur 127.0.0.1 limite dépassée. |
Les trois premières requêtes, comme vous pouvez le voir, se sont déroulées sans accroc. Les quatrième et cinquième requêtes, en revanche, ont été limitées en débit par votre script. Il y a de fortes chances que le serveur Redis ralentisse la vitesse à laquelle les utilisateurs peuvent effectuer des requêtes.
Vous avez spécifié des valeurs faibles pour les deux variables répertoriées ci-dessous dans ce guide :
|
1 2 3 4 |
... $max_calls_limit = 3; $time_period = 15; ... |
Lorsque vous déployez votre application en production, vous devriez envisager d'utiliser des valeurs plus élevées, en fonction de la fréquence d'utilisation prévue.
Il est recommandé d’examiner les statistiques en temps réel avant d'ajuster ces chiffres. Dans cet exemple, si les journaux de votre serveur indiquent qu'un utilisateur moyen visite votre application 1 000 fois toutes les 60 secondes, vous pouvez utiliser ce nombre comme exemple pour définir la limite de débit.
Conclusion
Dans ce guide, vous avez appris à utiliser un serveur Redis avec PHP sur Ubuntu 20.04. Bien que cet article montre comment fonctionne la limitation de débit avec Redis, vous pouvez l'adapter pour répondre aux besoins de votre application web. Nous vous encourageons à explorer des exemples concrets tels que la limite maximale de requêtes de Twitter, l’API JSON de recherche personnalisée de Google, et d'autres documentations similaires pour approfondir vos connaissances sur la limitation de débit et essayer d'expérimenter vous-même avec différentes limites de temps.
De plus, il existe de nombreux autres supports d'apprentissage sur Redis et PHP auxquels vous pouvez accéder depuis nos blogs:
- Déployer une application PHP sur un cluster Kubernetes avec Ubuntu 18.04
- Installer et sécuriser PHPmyadmin sur Ubuntu 20.04
- Comment installer la pile LEMP (Linux Nginx MySQL PHP) on Ubuntu 20.04
Bonne informatique !
Commentaires
Aucun commentaire pour l'instant. Soyez le premier.