Lua Academy · Aula

Dicionários de memória compartilhada

Armazene dados em cache entre trabalhadores com ngx.shared.DICT para consultas de baixa latência.

Dicionários de memória compartilhada é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

O que é ngx.shared.DICT?

ngx.shared.DICT é uma zona de memória compartilhada acessível por todos os processos de trabalho do Nginx. Ela fornece operações O(1) de obtenção, definição e incremento para armazenamento em cache e coordenação.

Declaração de memória compartilhada em nginx.conf

Alocar dicionários compartilhados com um nome e um tamanho no bloco http.

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

Obtenção e definição básicas

Armazene e recupere valores com um TTL opcional (tempo de vida em segundos).

-- 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!

Incremento atômico

dict:incr(key, delta, init, expiry) incrementa um contador atomicamente. Inicializa-o com init se a chave não existir.

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

Limitação de taxa com memória compartilhada

O padrão de incremento implementa um limitador de taxa de janela deslizante — um dos padrões mais comuns do OpenResty.

Exclusão e limpeza

dict:delete(key) remove uma única chave. dict:flush_all() marca todas as chaves como expiradas (exclusão tardia). dict:flush_expired(n) remove ativamente as chaves expiradas.

Adição atômica

dict:add(key, val, expiry) define uma chave somente se ela ainda não existir — útil para bloqueios distribuídos.

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

Planejamento do tamanho da memória compartilhada

Cada par de chave e valor tem uma sobrecarga (~100 bytes). Estimativa: size_mb * 1024^2 / avg_entry_size = número máximo de entradas. Monitore com dict:capacity() e dict:free_space().

Remoção de entradas da memória

Quando o dicionário está cheio, o OpenResty remove as entradas mais antigas para liberar espaço. Defina TTLs apropriados para controlar o comportamento de remoção.

Coordenação entre processos de trabalho

Como todos os processos de trabalho compartilham o mesmo dicionário, use :add para a eleição de líder e :incr para contadores globais entre todos os processos de trabalho.

Limitações

Os dicionários compartilhados aceitam somente valores escalares (texto, número e booleano). Armazene tabelas serializando-as para JSON com cjson.

Pergunta sobre memória compartilhada

O que dict:incr(key, 1, 0, 60) faz?

Recapitulação: dicionários de memória compartilhada

ngx.shared.DICT fornece operações atômicas O(1) de obtenção, definição e incremento entre todos os processos de trabalho. Use-o para limitação de taxa, armazenamento em cache e bloqueios distribuídos. Defina TTLs para controlar a remoção de entradas. Serialize tabelas para JSON quando precisar armazenar valores complexos.

Perguntas Frequentes

A aula “Dicionários de memória compartilhada” é grátis?

Sim — o texto completo de “Dicionários de memória compartilhada” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Dicionários de memória compartilhada”?

Armazene dados em cache entre trabalhadores com ngx.shared.DICT para consultas de baixa latência. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Dicionários de memória compartilhada”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Lua Academy