Expulsion redis cache

Généralement, un cache est un composant logiciel ou matériel qui détient les données des demandes des clients antérieurs, afin que les données puissent être récupérées et servies plus rapidement pour les demandes faites à l'avenir. Dans la plupart des cas, les systèmes backend ne sont pas aussi rapides que vous aimeriez qu'ils soient. Le cache se trouve entre votre couche de base de données backend et l'application client, fournissant une récupération rapide des données et un temps de réponse rapide.

Lorsque les données demandées sont disponibles dans le cache Redis, les données peuvent être directement servi à partir du cache Redis sans rediriger la demande vers la base de données principale, qui est appelée un hit de cache. D'un autre côté, si les données ne sont pas disponibles dans le cache Redis, la demande doit atteindre la base de données du backend d'origine pour récupérer les données comme d'habitude, qui est un miss de cache, mais les demandes ultérieures serviront à partir du cache.

Avec ce type de comportement, la mise en cache Redis est un excellent choix pour de nombreux cas d'utilisation.

• Inférences d'apprentissage automatique
• Recherches en texte intégral
• Requêtes de base de données relationnelles complexes
• Résultats de l'API tiers

Les caches Redis apportent à votre application plusieurs avantages tout en introduisant un défi majeur, qui est appelé Cache Staliness. À un moment donné, votre cache peut être pleine de données périmées qui ne sont même pas valables pour aujourd'hui. Par conséquent, il devrait y avoir un mécanisme pour expulser les données anciennes ou non valides alors que vous continuez à utiliser votre cache Redis avec de nouvelles données.

Expulsion redis cache

Lorsque Redis Cache a été introduit pour la première fois, les développeurs utilisaient la valeur TTL (temps pour vivre) pour chaque clé pour maintenir une quantité de mémoire relativement constante en correspondant à la vitesse des données entrant et sortant du système. C'était beaucoup de travail manuel pour les développeurs, ce que le serveur Redis devrait gérer.

Ainsi, l'approche idéale devrait être d'expulser automatiquement les anciennes données à mesure que la limite de mémoire de cache maximale est atteinte, qui est également le processus suivi du système Memcached. Redis utilise le spécial maxmemory Directive pour informer que la limite de mémoire maximale a été atteinte.

Directive de configuration maxmemory

Redis utilise la directive de configuration MaxMemory pour identifier la mémoire disponible maximale pour que le cache fonctionne sur. Il existe deux façons de définir la valeur de la directive maxmémory.

• En utilisant le redis.fichier de confr
• Commande de configuration de configuration à l'exécution

Ce qui suit est un exemple de redis.Fichier Conf qui montre comment vous pouvez spécifier la mémoire de cache maximale pour l'ensemble de données. Dans ce cas, la directive MaxMemory a été définie sur 1000 octets.

De même, la commande redis config set peut être utilisée pour définir la directive MaxMemory au moment de l'exécution, comme indiqué dans ce qui suit.

Config Set Maxmemory 100

De plus, si vous définissez la valeur de directive maxmemory sur 0, cela signifie qu'aucune limite de mémoire n'a été spécifiée pour le cache redis. Dans la plupart des systèmes 64 bits, cette valeur est définie sur 0. Le système 32 bits utilise implicitement la limite de mémoire maximale de 3 Go.

Lorsque le cache Redis atteint la valeur de mémoire spécifiée par la directive MaxMemory, elle commence à supprimer les clés en fonction de la politique d'expulsion sélectionnée. Si aucune clé ne répond aux critères de politique, alors rien ne sera expulsé. Au lieu de cela, le serveur Redis répondra avec des erreurs sur des commandes comme Lpush et définira qui consomme plus de mémoire et répondra uniquement aux commandes en lecture seule comme Get.

Dans la section suivante, nous discuterons des politiques d'expulsion de redis et comment elles déterminent quelles clés doivent être expulsées ou non.

Politiques d'expulsion

Une politique d'expulsion détermine le comportement du cache redis lorsque la valeur maxmémory est atteinte. Redis supprimera toutes les clés qui répondent aux critères de politique donnés à un moment donné. Par conséquent, il est important de s'assurer que vous avez une base de données suffisamment grande pour conserver les clés souhaitées. Les sections suivantes décrivent les différentes politiques d'expulsion de redis disponibles pour une utilisation.

Plusieurs politiques d'expulsion sont disponibles à l'utilisation, et noviction est l'une des plus utilisées si vous ne souhaitez pas supprimer de vieilles touches lorsque la limite de mémoire maximale est atteinte. Cependant, il lancera des erreurs sur toutes les opérations d'écriture de Redis afin d'informer l'utilisateur que le cache est plein et libére de l'espace. En bref, les données ne seront pas enregistrées dans le cache tant que vous ne libèrez pas un espace manuellement.

Dans le volatile-ttl Politique, Redis prélève des échantillons de clés dont les champs expirés sont définis sur vrai et explique ceux avec la plus petite valeur TTL. S'il n'y a pas de clés avec le champ Expire réglé sur true, alors aucune expulsion ne se produit, ce qui est similaire à noviction politique.

Ceci est une autre version de la politique volatile-TTL où Redis supprime aléatoirement les clés dont le champ Expire est défini sur true. Encore une fois, il ne considère que les clés qui ont une valeur TTL mais pas l'espace de la clé entière.

Ceci est plus similaire à aléatoire politique, mais avec le AllKeys-Random Politique, l'espace clé entier sera pris en compte, pas seulement les clés avec une valeur TTL. Dans ce cas, Redis expulsera les clés au hasard pour ajouter de nouvelles données.

Les deux politiques ci-dessus utilisent un algorithme aléatoire pour expulser les clés du cache, ce qui est assez risqué et peut ne pas être le moyen optimal de faire l'expulsion clé. Ainsi, Redis a introduit un moyen plus optimal de le faire avec le nouveau LRU (le moins récemment utilisé) algorithme.

L'algorithme LRU (le moins récemment utilisé)

L'algorithme LRU est basé sur l'hypothèse que si une clé donnée a été accessible récemment, il y a une plus grande probabilité d'y accéder dans un avenir proche. D'un autre côté, si nous n'avons pas utilisé de clé donnée depuis longtemps, il y a de plus en plus de chances que la clé ne soit pas utilisée bientôt ou jamais à nouveau. Avec cette hypothèse, l'algorithme LRU essaie d'expulser les clés les moins récemment utilisées du cache Redis, qui est une approche plus optimale que les algorithmes d'expulsion des clés aléatoires.

Pour implémenter cette politique, l'objet redis utilise un nouveau LRU champ avec 24 bits attribués, qui garde une trace de la dernière utilisation de la clé. Avec l'algorithme LRU en place, il faut un nombre spécifié de clés aléatoires et expulse celui avec le plus de temps de ralenti le plus élevé ou le plus ancien. La directive MaxMemory-Samples est utilisée pour spécifier le nombre de clés par échantillon. Cela peut être défini à l'aide de la commande config set, comme indiqué dans ce qui suit.

Config définir les échantillons maxmemory 5

Il est important de garder à l'esprit que Redis exécute une approximation de l'algorithme LRU pour garder les choses simples et enregistrer des ressources informatiques comme le processeur et la mémoire.

Il y a deux saveurs de politique d'expulsion LRU.

Les clés les moins récemment utilisées avec le champ Expire réglé sur True seront supprimées. Les clés qui ne sont pas associées à une valeur TTL ne seront pas expulsées en vertu de cette politique car l'échantillon n'est prélevé que des clés dont le champ Expire est défini sur True.

Toutes les clés avec le temps de ralenti le plus élevé seront supprimées. Dans ce cas, Redis gardera les clés les plus récemment utilisées.

L'algorithme LFU (le moins fréquemment utilisé)

Redis a introduit le nouvel algorithme LFU (le moins fréquemment utilisé) dans la version 4.0 pour identifier les clés rarement utilisées et les retirer du cache lorsque la limite de mémoire maximale est atteinte. Avec la politique LFU, les clés accessibles trop souvent.

Les clés avec les champs Expire définies sur True et celles qui sont les moins fréquemment utilisées parmi l'échantillon sélectionné seront expulsées.

Il recherche l'ensemble de l'espace des clés pour des clés rarement utilisées et les supprime tout en gardant les clés fréquemment utilisées.

Conclusion

Pour conclure, Redis utilise la directive MaxMemory pour spécifier la limite de mémoire maximale du cache redis. Comme discuté, lorsque le cache atteint sa limite de mémoire maximale, la politique d'expulsion configurée tirera et supprimera les clés. Redis utilise les approximations des algorithmes LRU et LFU pour trouver les meilleurs candidats à l'expulsion.