0Pricing
Lua Academy · Leçon

Limites de ressources et instrumentation

Utilisez debug.sethook pour compter les instructions et faire respecter des budgets CPU.

Limites de ressources et instrumentation 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.

Pourquoi limiter les ressources ?

Du code non fiable peut provoquer un DoS en s'exécutant indéfiniment (CPU), en allouant des quantités énormes de mémoire ou en générant une sortie excessive. Les limites de ressources protègent l'hôte.

Limite du CPU avec debug.sethook

Comptez les instructions exécutées et interrompez l'exécution lorsque la limite est dépassée.

local function withCPULimit(fn, maxOps)
  local ops = 0
  debug.sethook(function()
    ops = ops + 1
    if ops > maxOps then error("CPU limit exceeded", 2) end
  end, "", 50)  -- check every 50 instructions
  local ok, result = pcall(fn)
  debug.sethook()
  return ok, result
end

Granularité du comptage

Le troisième argument de sethook (décompte) contrôle la fréquence d'appel de la fonction d'interception. Des valeurs plus petites offrent une meilleure précision, mais entraînent davantage de surcharge. Une valeur comprise entre 50 et 500 est courante.

Limite mémoire avec collectgarbage

Vérifiez l'utilisation de la mémoire dans la fonction d'interception et interrompez l'exécution si elle dépasse un seuil.

local MEM_LIMIT_KB = 1024  -- 1 MB
debug.sethook(function()
  if collectgarbage("count") > MEM_LIMIT_KB then
    error("Memory limit exceeded")
  end
end, "", 200)

Limite du temps réel

Combinez cette approche avec os.clock() pour limiter le temps réel plutôt que le nombre d'instructions, ou en complément de celui-ci.

local deadline = os.clock() + 0.5  -- 500ms
debug.sethook(function()
  if os.clock() > deadline then
    error("Time limit exceeded")
  end
end, "", 100)

Limite de sortie

Enveloppez la fonction print du bac à sable pour compter les octets écrits et refuser toute sortie supplémentaire après une limite.

local totalOutput = 0
local OUTPUT_LIMIT = 10240  -- 10 KB
env.print = function(...)
  local s = table.concat({...}, "\t") .. "\n"
  totalOutput = totalOutput + #s
  if totalOutput > OUTPUT_LIMIT then
    error("Output limit exceeded")
  end
  output[#output+1] = s
end

Instrumentation du profilage

Utilisez les événements d'appel et de retour de la fonction d'interception pour construire un graphe d'appels instrumenté du code exécuté en bac à sable.

local callGraph = {}
debug.sethook(function(event)
  local info = debug.getinfo(2, "Sn")
  local name = info.name or info.short_src
  if event == "call" then callGraph[name] = (callGraph[name] or 0) + 1 end
end, "c")

Fonctions d'interception des coroutines

Les limites de debug.sethook s'appliquent par thread. Installez une fonction d'interception sur chaque coroutine si le code en bac à sable crée des coroutines.

Rapport sur l'utilisation des ressources

Après l'exécution dans le bac à sable, indiquez : le nombre d'instructions exécutées, la mémoire utilisée, la longueur de la sortie et le temps écoulé. Ces informations sont utiles pour détecter les abus et appliquer les quotas.

Bacs à sable imbriqués

Si un module en bac à sable peut lui-même créer des sous-bacs à sable, assurez-vous que les limites de ressources du bac parent sont héritées par l'enfant ou renforcées pour celui-ci.

Outils pour la production

Outils : luasandbox (LuaJIT), conteneurs Docker pour Lua avec seccomp, allocateurs personnalisés qui plafonnent strictement la mémoire. Combinez-les avec les cgroups au niveau de l'OS pour obtenir de solides garanties.

Question sur les limites de ressources

Comment debug.sethook impose-t-il une limite de CPU ?

Récapitulatif : limites de ressources et instrumentation

Utilisez debug.sethook pour imposer des limites de CPU (nombre d'instructions), de mémoire (vérification avec collectgarbage) et de temps (os.clock). Enveloppez print pour limiter la sortie. Indiquez l'utilisation après l'exécution afin d'assurer la surveillance et l'application des quotas.

Questions Fréquemment Posées

La leçon « Limites de ressources et instrumentation » est-elle gratuite ?

Oui — le texte complet de « Limites de ressources et instrumentation » 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 « Limites de ressources et instrumentation » ?

Utilisez debug.sethook pour compter les instructions et faire respecter des budgets CPU. 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 « Limites de ressources et instrumentation » ?

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

  1. Le modèle _ENV de Lua 5.2+
  2. Construire un bac à sable restreint
  3. Empêcher les sorties du bac à sable
  4. Limites de ressources et instrumentation
← Retour à Lua Academy