Lua Academy · Leçon

Dictionnaires de mémoire partagée

Mettez les données en cache entre les processus de travail avec ngx.shared.DICT pour des recherches à faible latence.

Dictionnaires de mémoire partagée est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Qu’est-ce que ngx.shared.DICT ?

ngx.shared.DICT est une zone de mémoire partagée accessible à tous les processus de travail de Nginx. Elle fournit des opérations get/set/incr en O(1) pour la mise en cache et la coordination.

Déclaration de la mémoire partagée dans nginx.conf

Allouez des dictionnaires partagés avec un nom et une taille dans le bloc http.

# nginx.conf
http {
  lua_shared_dict rate_limit 10m;
  lua_shared_dict cache      50m;
  lua_shared_dict locks      1m;
}

Lecture et écriture de base

Stockez et récupérez des valeurs avec un TTL facultatif (durée de vie en secondes).

-- content_by_lua_block
local cache = ngx.shared.cache
cache:set("greeting", "Hello, World!", 60)  -- expires in 60s
local val = cache:get("greeting")
ngx.say(val)  -- Hello, World!

Incrémentation atomique

dict:incr(key, delta, init, expiry) incrémente un compteur de manière atomique. Il l’initialise à init si la clé n’existe pas.

local rl = ngx.shared.rate_limit
local count = rl:incr("req:" .. ngx.var.remote_addr, 1, 0, 60)
if count > 100 then
  ngx.exit(429)  -- Too Many Requests
end

Limitation du débit avec la mémoire partagée

Le modèle incr implémente un limiteur de débit simple à fenêtre glissante — l’un des modèles OpenResty les plus courants.

Suppression et vidage

dict:delete(key) supprime une seule clé. dict:flush_all() marque toutes les clés comme expirées (suppression différée). dict:flush_expired(n) supprime activement les clés expirées.

Ajout atomique

dict:add(key, val, expiry) définit une clé uniquement si elle n’existe pas déjà — ce qui est utile pour le verrouillage distribué.

local locks = ngx.shared.locks
local ok, err = locks:add("my_lock", true, 5)  -- 5s lock
if not ok then
  ngx.say("Lock held, try later")
  return
end
-- critical section
-- locks:delete("my_lock")  -- release

Planification de la taille de la mémoire partagée

Chaque paire clé-valeur entraîne une surcharge (~100 octets). Estimation : size_mb * 1024^2 / avg_entry_size = nombre maximal d’entrées. Surveillez l’utilisation avec dict:capacity() et dict:free_space().

Éviction de la mémoire

Lorsque le dictionnaire est plein, OpenResty évince les entrées les plus anciennes pour libérer de la place. Définissez des TTL appropriés pour contrôler le comportement d’éviction.

Coordination entre processus de travail

Puisque tous les processus de travail partagent le même dictionnaire, utilisez :add pour l’élection d’un chef et :incr pour les compteurs globaux entre tous les processus de travail.

Limites

Les dictionnaires partagés prennent uniquement en charge les valeurs scalaires (chaîne, nombre, booléen). Stockez les tables en les sérialisant au format JSON avec cjson.

Question sur la mémoire partagée

Que fait dict:incr(key, 1, 0, 60) ?

Récapitulatif : dictionnaires en mémoire partagée

ngx.shared.DICT fournit des opérations atomiques de lecture, d’écriture et d’incrémentation en O(1) entre tous les processus de travail. Utilisez-le pour la limitation du débit, la mise en cache et le verrouillage distribué. Définissez des TTL pour contrôler l’éviction. Sérialisez les tables au format JSON pour les valeurs complexes.

Questions Fréquemment Posées

La leçon « Dictionnaires de mémoire partagée » est-elle gratuite ?

Oui — le texte complet de « Dictionnaires de mémoire partagée » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Dictionnaires de mémoire partagée » ?

Mettez les données en cache entre les processus de travail avec ngx.shared.DICT pour des recherches à faible latence. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Dictionnaires de mémoire partagée » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Lua Academy