SSD Nodes Learn Hosting plans →
Guides Matt ConnorPar Matt Connor · Mis à jour le 2026-10-21

Auto-héberger Dormice pour les sandbox d’agents

Installez Dormice sur un VPS Linux, exécutez du code non fiable dans un sandbox compatible E2B, vérifiez l’isolation et dimensionnez votre hôte.

Ce qu’est Dormice et ce qu’il n’est pas

Dormice est un agent sandbox auto-hébergé : un daemon sur un VPS Linux dont vous êtes propriétaire. Votre code d’agent l’appelle via HTTP pour exécuter du code non fiable dans un conteneur isolé. Votre programme demande un sandbox par son nom, récupère le même sandbox quel que soit son état, y exécute une commande, puis lit la sortie. Le sandbox est une ressource gérée par programme, pas une machine à laquelle vous vous connectez.

Cette approche est différente du fait de donner un ordinateur complet à un agent. Une VM éphémère pour un agent de codage est une machine à laquelle vous vous connectez en SSH, que vous laissez l’agent détériorer, puis que vous supprimez. Dormice se situe un niveau en dessous : c’est l’API d’exécution appelée par votre programme lorsqu’il dispose déjà du code et a besoin d’un environnement sûr pour l’exécuter. Utilisez la VM éphémère lorsqu’une machine complète constitue l’unité de travail. Utilisez Dormice lorsqu’un seul appel exec constitue l’unité de travail et que vous voulez en effectuer cent par jour sans déployer cent VM.

Le projet se présente comme compatible avec E2B. E2B est un service de sandbox hébergé dont la bibliothèque cliente est déjà importée par de nombreux frameworks d’agents. Dormice expose le même protocole sous ses propres préfixes d’URL. Une application écrite avec le package e2b officiel continue donc de fonctionner lorsque vous la dirigez vers votre propre serveur. Le code de l’application ne change pas. Seuls deux URL et un préfixe de clé API changent.

Ce que signifie en pratique « le SQLite des sandbox d’agents »

SQLite est une base de données que l’on intègre au lieu d’exploiter un service distinct, et Dormice reprend directement cette comparaison. Une seule daemon par machine, un seul fichier SQLite pour son registre, un seul port TCP, avec une petite gateway installée à ses côtés pour servir la console web. Pas de Kubernetes ni de serveur de base de données externe. La daemon prend un verrou exclusif à côté de son registre. Une seconde daemon sur la même machine refuse donc de démarrer au lieu de diviser silencieusement l’état. Chaque sandbox reste sur la machine où elle a été créée. Le README décrit désormais une fleet comme une gateway et les machines de son réseau privé. Il précise toutefois que si vous avez besoin de sandbox qui se déplacent entre les machines, ou d’une fleet répartie entre plusieurs régions, vous devez choisir une autre solution et en tenir compte.

La deuxième partie de l’idée concerne le coût. Un sandbox hébergé est facturé pour chaque seconde d’existence. Les sandbox hébergés sont donc conçus pour être jetables. Dormice fonctionne sur du matériel que vous payez déjà. Ses sandbox sont donc permanents et coûtent moins cher plus ils restent inactifs. Un sandbox refroidit progressivement : actif, puis gelé, puis arrêté, puis archivé. Chaque opération acquire le réactive depuis l’état qu’il a atteint.

Le gel est le point important à comprendre. C’est lui qui rend abordable la conservation permanente du sandbox de chaque agent. Les chiffres ci-dessous sont ceux publiés par le projet. Ils ont été mesurés sur son matériel, pas sur le vôtre.

GraphiqueOne idle sandbox before and after freezing, figures published by the project
Les données de ce graphique
[
  {
    "label": "Active, holding 1 GiB",
    "resident_memory_mib": 1024,
    "wake_ms": 0
  },
  {
    "label": "Frozen",
    "resident_memory_mib": 5,
    "wake_ms": 50
  }
]

Un sandbox inactif qui utilise 1024 Mio de mémoire tombe à 5 Mio de mémoire résidente après le gel, puis revient en environ 50 ms. Les processus sont suspendus puis repris sur place. Un agent à longue durée de vie conserve donc l’état de son shell et son travail en cours pendant le gel. Reproduisez ce comportement sur votre propre hôte avant de dimensionner votre capacité en conséquence.

Ce dont l’hôte a besoin avant l’installation

L’hôte doit exécuter Ubuntu ou Debian sur x86_64, et l’installateur a besoin de root. Le daemon conserve les privilèges root à l’exécution, car il effectue des loop mounts et écrit dans les cgroups.

Les sandboxes s’exécutent dans Docker avec gVisor (un container runtime qui place un kernel en espace utilisateur entre le conteneur et le kernel de l’hôte), qui fournit le runtime runsc utilisé par chaque sandbox. Node 22 ou une version ultérieure exécute le daemon. Si la version système de Node est déjà 22 ou ultérieure, l’installateur la réutilise. Si elle est absente ou plus ancienne, l’installateur télécharge sa propre copie versionnée, vérifie sa checksum et la décompresse sous /opt.

Le swap doit exister, et vm.swappiness doit être égal à 100. Ce n’est pas un conseil d’optimisation, mais une exigence fonctionnelle. Le gel fonctionne en envoyant la mémoire d’une sandbox inactive vers le swap. gVisor conserve la mémoire de la sandbox dans une mémoire partagée, et le kernel ne swap pas la mémoire partagée avec la valeur par défaut de swappiness. Le projet a mesuré 0 octet récupéré avec la valeur par défaut, contre 99.5 pour cent avec 100. Vérifiez la valeur réellement utilisée par le kernel, car certaines images cloud définissent vm.swappiness = 0 dans un fichier que vous ne penserez jamais à consulter.

sysctl vm.swappiness
swapon --show

sysctl vm.swappiness doit afficher vm.swappiness = 100, et swapon --show doit lister un swapfile. Si swappiness affiche 0, chaque gel est sans effet et vous continuez à payer le coût mémoire complet de chaque sandbox inactive.

Installer Dormice sur Ubuntu

L’installation documentée consiste à envoyer un pipe vers bash :

curl -fsSL https://raw.githubusercontent.com/BitMiracle-AI/Dormice/main/deploy/install.sh | bash

Téléchargez ce script et lisez-le avant de l’exécuter. Il s’exécute avec les privilèges root et modifie votre hôte : il installe Docker s’il est absent, télécharge gVisor et Caddy après vérification des sommes de contrôle, crée un swapfile si l’hôte n’a pas de swap, écrit les unités systemd du daemon, de la gateway et d’un registre d’images, puis ajoute des règles de firewall.

curl -fsSL https://raw.githubusercontent.com/BitMiracle-AI/Dormice/main/deploy/install.sh -o dormice-install.sh
less dormice-install.sh
sudo bash dormice-install.sh --swap-gb 8

--swap-gb définit la taille du swapfile et utilise 16 par défaut, ce qui représente beaucoup d’espace disque sur un petit VPS. --mirror cn redirige les téléchargements vers des mirrors accessibles depuis la Chine continentale. Réexécuter l’installer met le code à niveau et corrige les écarts de configuration. Il ne renouvelle jamais votre API token.

Le code est installé dans /opt/dormice, la configuration dans /etc/dormice/env (ainsi que dans /etc/dormice/gateway.env pour la gateway), les données des sandbox dans /var/lib/dormice, et les commandes dormice et dor dans /usr/local/bin. L’installer génère l’API token pendant l’installation et l’écrit dans /etc/dormice/env avec le mode 600. La même valeur est écrite dans le fichier de la gateway.

Aucune release taguée n’est disponible pour l’installation. Au 12 octobre 2026, le dépôt ne contient aucun tag git ni aucune release GitHub. L’installer clone donc main, et vous obtenez ce qui a été ajouté ce matin-là. Pour figer une version, vous devez donc noter le commit réellement installé.

git -C /opt/dormice rev-parse HEAD

Enregistrez ce hash avec vos notes de déploiement. Il indique exactement quel code vous exécutez. Il ne permet pas à lui seul de revenir en arrière : les nouveaux processus appliquent les migrations de base de données au démarrage, et la documentation de mise à niveau précise qu’une migration n’est pas annulée en réexécutant un installer plus ancien. Avant de redémarrer quoi que ce soit, l’installer enregistre des snapshots des deux bases de données dans /var/lib/dormice/backups/ et conserve les trois plus récents. Ces snapshots constituent la méthode documentée pour revenir en arrière après une mise à niveau défectueuse. Copiez donc le plus récent hors de la machine avant toute nouvelle mise à niveau.

L’installer termine en exécutant dor doctor, un contrôle de l’hôte en lecture seule qui démarre de véritables conteneurs gVisor pour vérifier que le runtime fonctionne, au lieu de se fier à une liste de paquets. Exécutez-le de nouveau lorsque le daemon se comporte anormalement.

sudo dor doctor
systemctl is-active dormice

systemctl is-active dormice doit afficher active. S’il affiche failed, journalctl -u dormice -n 50 contient la raison. Un démarrage en échec est généralement lié au swap ou à un prérequis gVisor, et non au daemon lui-même.

L’installer installe également Caddy sur la machine. Vérifiez donc les ports en écoute avant de considérer la configuration du firewall comme terminée.

sudo ss -lntp

Le daemon écoute toujours sur 127.0.0.1. Par conception, aucun paramètre ne permet de modifier cette adresse. Seul le port peut changer : DORMICE_PORT utilise 3676 par défaut. La gateway située à côté suit la même règle sur 127.0.0.1:3677, avec DORMICE_GATEWAY_PORT pour le port et volontairement aucun paramètre d’hôte. Accéder à l’un ou l’autre depuis votre ordinateur portable est une action volontaire. La solution la plus simple consiste à utiliser un tunnel SSH qui redirige les deux ports.

ssh -L 3676:127.0.0.1:3676 -L 3677:127.0.0.1:3677 root@your-server

Une fois le tunnel ouvert, http://127.0.0.1:3677/console sur votre ordinateur portable ouvre la console web, servie par la gateway. Lors de votre première visite, collez une fois l’API token pour prouver que vous êtes l’opérateur, puis définissez un nom d’utilisateur et un mot de passe pour la console. La connexion définit un cookie de session httpOnly valable 7 jours, que le JavaScript de la page ne peut pas lire. La console n’affiche jamais de nouveau le token. Sa page Connect affiche des extraits de configuration client prêts à être copiés-collés et déjà configurés pour pointer vers votre propre endpoint.

Créer un sandbox et y exécuter du code

Une opération crée un sandbox : acquire. Elle est idempotente : la même clé renvoie toujours le même sandbox, en le créant, en le réveillant, en le démarrant ou en le restaurant selon les besoins. Tous les autres verbes renvoient 404 pour une clé qu’ils n’ont jamais rencontrée. La dor CLI ne possède pas de verbe acquire. Votre premier sandbox vient donc de la console ou d’une client library.

La route de la console est la plus rapide. Ouvrez /console via le tunnel et créez un sandbox nommé my-agent. La CLI peut ensuite l’utiliser.

sudo grep DORMICE_API_TOKEN /etc/dormice/env
export DORMICE_ENDPOINT=http://127.0.0.1:3676
export DORMICE_API_TOKEN=paste-the-value-here
dor sandbox ls
dor sandbox exec my-agent 'python3 --version'

dor sandbox ls répertorie chaque sandbox avec son état du cycle de vie. C’est ainsi que vous pouvez surveiller le passage de l’état active à l’état frozen. dor sandbox exec affiche une version de Python 3.12, car l’image standard est Ubuntu 24.04 avec Python 3.12, Node 24, git et ripgrep déjà installés. Une erreur d’authentification signifie que la ligne du token que vous avez copiée incluait le nom de la variable.

Les fichiers sont transférés avec dor sandbox push my-agent ./script.py, qui les place dans /home/user/script.py, et dor sandbox pull my-agent notes.txt permet d’en récupérer un. Les verbes natifs de gestion des fichiers limitent chaque fichier à 16 MiB, tandis que l’interface de fichiers E2B utilise un flux et laisse le quota disque du sandbox constituer la seule limite.

La destruction est la seule opération qui entraîne une perte de données. dor sandbox destroy my-agent supprime le sandbox et est idempotent. Le README principal, la compétence d’agent incluse et le README du package CLI la documentent tous sous ce même nom. Exécutez tout de même dor sandbox --help sur votre propre build, car l’installer suit main et la CLI continue de s’enrichir.

Pointez votre code E2B existant vers votre propre serveur

C’est la raison principale de vous y intéresser. Le package officiel e2b installé depuis npm, sans modification, communique avec Dormice. Exécutez ceci depuis votre ordinateur portable avec le tunnel SSH ouvert. Aucun nouveau service n’écoute ainsi sur le serveur.

npm init -y
npm i e2b tsx
import { Sandbox } from 'e2b';

const sbx = await Sandbox.create({
  apiKey: `e2b_${process.env.DORMICE_API_TOKEN}`,
  apiUrl: 'http://127.0.0.1:3676/e2b/api',
  sandboxUrl: 'http://127.0.0.1:3676/e2b/envd',
});

const result = await sbx.commands.run('python3 -c "print(6 * 7)"');
console.log(result.exitCode, result.stdout);

await sbx.kill();
DORMICE_API_TOKEN=paste-the-value-here npx tsx index.ts

Une exécution correcte affiche le code de sortie 0 et 42. La clé API est votre token Dormice précédé du préfixe e2b_. C’est le format attendu par la couche de compatibilité.

La compatibilité ne se limite pas à un stub. La suite de tests de bout en bout du projet utilise le package officiel avec un daemon Docker et gVisor réel pour tester la sortie standard et la sortie d’erreur en streaming, les commandes en arrière-plan, un PTY interactif, les URL d’upload et de download signées, la surveillance de répertoires et un proxy de port. Quelques différences doivent être prises en compte avant toute migration réelle :

  • La création de templates n’est pas implémentée. Un template est une image Docker que vous construisez vous-même et enregistrez avec dor template add. Sandbox.create('name') la résout ensuite. Un nom non enregistré renvoie une erreur 404 au lieu d’être accepté comme s’il existait.
  • Les sandboxes créés via l’interface E2B ont de vraies échéances, car la sémantique E2B l’exige. Aucune échéance n’est imposée aux sandboxes créés via l’API native.
  • Une sandbox gelée conserve ses processus et les reprend là où ils en étaient. Ici, la mise en pause et la reprise ne correspondent donc pas à l’arrêt puis au redémarrage à froid auxquels vous êtes peut-être habitué.

Ce que le sandbox bloque et ce qu’il ne bloque pas

gVisor intercepte les appels système du conteneur dans l’espace utilisateur et les traite lui-même. Le code exécuté dans le sandbox ne communique donc pas directement avec le kernel de l’hôte. Dans le sandbox, les commandes s’exécutent sous user (uid 1000), mais ce compte dispose de sudo sans mot de passe. Le compte root est donc accessible à tout code qui le demande. Ne considérez pas l’uid comme une protection : le projet indique clairement que la frontière de sécurité est gVisor, et non l’uid. Même un sandbox qui élève ses privilèges ne peut toujours pas accéder au kernel de l’hôte. Cela couvre le cas courant : un script généré qui exécute rm -rf /, remplit le disque ou crée des processus en boucle jusqu’à provoquer un arrêt endommage son propre sandbox et s’arrête là.

Voici ce que le sandbox ne bloque pas. C’est à vous de gérer chacun de ces points.

  • Un sandbox dispose d’un accès réseau sortant fonctionnel. Le code généré peut télécharger ce qu’il veut et envoyer tout ce qu’il trouve. Le renforcement réseau de l’installateur couvre deux points précis : il bloque le trafic des conteneurs vers le service de métadonnées cloud sur 169.254.0.0/16 et sur 100.100.100.200, l’adresse utilisée par Alibaba Cloud, qui permet au cloud de transmettre les identifiants de l’instance à tout ce qui peut l’atteindre ; il désactive aussi le trafic entre conteneurs avec "icc": false dans daemon.json de Docker. Rien d’autre n’est bloqué. Consultez sudo iptables -S DOCKER-USER et ajoutez vos propres règles DROP pour les plages privées qu’un sandbox ne devrait pas pouvoir atteindre.
  • Docker insère ses propres règles avant celles de votre firewall. Un port de conteneur publié peut donc répondre depuis Internet alors qu’ufw indique qu’il est fermé. Consultez la publication des ports par Docker en contournant ufw et les bases du firewall ufw pour un VPS avant d’exposer quoi que ce soit sur cet hôte.
  • gVisor est un kernel dans l’espace utilisateur, pas un hyperviseur. Il s’agit d’un compromis volontaire : pour permettre le gel, les sandbox doivent être des processus, et exiger KVM empêcherait l’installation partout. Si votre modèle de menace exige une virtualisation matérielle, utilisez une isolation de type Firecracker et acceptez le coût d’exploitation qui l’accompagne.
  • Le token d’API constitue toute la frontière de sécurité côté client. Toute personne ou tout processus détenant DORMICE_API_TOKEN peut créer, lire et détruire chaque sandbox de la machine. Attribuez au processus agent son propre utilisateur avec le principe du moindre privilège sur le VPS et traitez ce token comme une clé SSH. Les pratiques décrites dans l’exécution sûre de Claude Code sur un VPS s’appliquent directement.

Le daemon lui-même s’exécute en tant que root sur votre hôte. gVisor protège l’hôte contre le code exécuté dans un sandbox, mais rien ne protège l’hôte contre le daemon ou contre toute personne qui détient son token. La machine qui exécute Dormice doit donc être dédiée à cette seule tâche. Si votre agent accède également à des outils via MCP (model context protocol), gardez ces serveurs MCP sur un VPS distinct pour la même raison.

Combien de sandbox tiennent dans 4 GB et 8 GB ?

Deux éléments consomment de la mémoire : la consommation de base de l’hôte et le working set de chaque sandbox actuellement actif. Réservez environ 1 GB pour Ubuntu, Docker et le daemon, puis divisez la mémoire restante par la consommation réelle d’un sandbox. Un sandbox qui exécute un script Python lisant quelques fichiers utilise environ 200 à 300 MiB. Un sandbox qui exécute un compilateur ou une suite de tests complète peut dépasser 1 gibibyte.

GraphiqueConcurrent sandboxes by host RAM, arithmetic after a 1 GB host reserve
Les données de ce graphique
[
  {
    "host": "4 GB VPS",
    "active_at_512_mib": 6,
    "active_at_1_gib": 3,
    "frozen_on_16gb_swap": 16
  },
  {
    "host": "8 GB VPS",
    "active_at_512_mib": 14,
    "active_at_1_gib": 7,
    "frozen_on_16gb_swap": 16
  }
]

Un VPS de 4 GB peut garder environ 6 sandbox actifs en même temps si chacun utilise 512 MiB, ou 3 si chacun utilise 1 gibibyte complet. Avec 8 GB, ces valeurs passent à 14 et 7. Ce sont des plafonds pour les tâches concurrentes, calculés arithmétiquement et non mesurés par benchmark. Surveillez donc free -m pendant l’exécution de votre propre charge.

Les sandbox gelés sont limités par le swap plutôt que par la RAM, ce qui constitue l’objectif de cette conception. Un sandbox gelé qui utilisait 1 gibibyte conserve environ cette quantité dans le swap et presque rien en mémoire résidente. Le fichier de swap de 16 GB créé par défaut par l’installateur peut donc en stocker environ 16. Au-delà, ils doivent passer à l’état arrêté, où ils ne consomment que de l’espace disque. Le disque constitue la vraie limite à long terme : chaque sandbox conserve son filesystem, et quelques dizaines d’agents contenant chacun un répertoire node_modules rempliront un petit volume bien avant que la mémoire ne devienne un problème.

Geler, arrêter, archiver : les paramètres du cycle de vie

Les valeurs par défaut sont un gel après 10 minutes d’inactivité, un arrêt après 3 jours et un archivage après 7 jours lorsque l’archivage est configuré. Définir stopAfterSeconds sur null vous donne un agent résident : il peut se mettre en veille lorsqu’il est inactif et ne nécessite jamais de démarrage à froid.

L’archivage est facultatif, et le daemon le gère explicitement. Configurez un stockage compatible S3 dans la page des paramètres de la console (les quatre variables DORMICE_S3_* existent toujours, mais servent uniquement de valeurs initiales pour le premier démarrage de la gateway) ; le disque d’un sandbox arrêté est alors empaqueté avec tar et zstd, envoyé vers le bucket, puis libéré localement. Ce bucket peut être un bucket MinIO que vous hébergez vous-même sur une autre de vos machines. Si le stockage n’est pas configuré, les sandboxes restent définitivement à l’état arrêté, et une policy demandant un archivage est refusée au lieu d’être ignorée silencieusement. Les restaurations sont visibles et non silencieuses : le prochain acquire répond immédiatement avec un statut de restauration et une valeur de progression, puis passe à l’état ready une fois le disque restauré.

Faut-il déjà en dépendre ?

Réponse directe : non, pas pour un usage que vous ne pouvez pas reconstruire. Le dépôt a été créé le 8 juillet 2026. Au 12 octobre 2026, il compte 1,509 stars, 109 forks, une licence Apache-2.0 et aucune release taguée. La ligne d’état du README indique elle-même que rien n’est prêt pour la production.

Cette combinaison présente un risque bien précis. Le code évolue sous vos pieds, car l’installateur suit main. L’interface est encore en cours de stabilisation : la documentation décrit désormais une gateway devant le daemon, avec son propre port, son propre fichier de configuration et sa propre base de données. De plus, un projet âgé d’environ trois mois peut tout simplement s’arrêter, puisqu’aucune clause de licence n’oblige quiconque à poursuivre son développement.

La compatibilité E2B rend ce risque gérable. Votre application communique avec un protocole qui dispose d’une implémentation hébergée. Si Dormice s’arrête, vous modifiez deux URLs et vous continuez à travailler. Développez votre agent contre l’interface E2B plutôt que contre l’API native afin de conserver cette possibilité de sortie. Le package natif @dormice/sdk n’est pas encore disponible sur npm non plus. Son utilisation nécessite donc de le construire depuis le dépôt, ce qui constitue une seconde raison de commencer par la voie compatible.

Exécutez-le là où vous pouvez vous permettre de le perdre. Reconstruisez l’hôte depuis un script, ne placez le token dans aucun prompt ni commit, et sortez des sandboxes tout ce que vous souhaitez conserver selon votre propre calendrier de sauvegarde.

FAQ

Dormice est-il prêt pour la production ?

Non, et le projet le précise lui-même. La ligne d’état du README indique que rien n’est encore prêt pour la production. Au 12 octobre 2026, le dépôt a environ trois mois, ne contient aucun tag Git ni aucune release. Il n’existe donc aucun numéro de version à figer. L’installateur clone la branche main, ce qui signifie que chaque exécution récupère le commit le plus récent. Notez git -C /opt/dormice rev-parse HEAD après chaque installation. Conservez une copie des snapshots de la base de données écrits par l’installateur dans /var/lib/dormice/backups/. Conservez également toutes les données importantes en dehors des sandboxes.

Quelle est la différence entre Dormice et une VM éphémère pour mon agent ?

Une VM éphémère est une machine avec SSH que vous créez pour une session, puis que vous supprimez. Dormice est une API d’exécution : votre programme appelle acquire, puis exec, et récupère stdout ainsi qu’un code de sortie, sans session shell intermédiaire. La VM convient à un humain ou à un agent qui a besoin d’un ordinateur complet pendant un certain temps. Dormice convient à une application qui exécute du code généré plusieurs fois par jour et qui ne veut pas supporter la préparation et la suppression d’une machine complète à chaque exécution.

Le SDK E2B officiel fonctionne-t-il vraiment sans modification du code ?

Oui, avec des modifications de configuration. Faites pointer apiUrl et sandboxUrl vers /e2b/api et /e2b/envd sur votre daemon. Transmettez votre token Dormice comme clé d’API, avec un préfixe e2b_. L’exécution de commandes, les sessions PTY, le transfert de fichiers, les URL signées et le proxy de ports sont tous couverts par la suite end-to-end du projet, exécutée avec le package officiel. La création de templates est la principale limitation : e2b template build n’est pas implémenté. Un template est donc une image Docker que vous construisez et enregistrez avec dor template add.

Combien de sandboxes peuvent fonctionner sur un VPS de 4 GB ?

Environ 6 peuvent rester actives simultanément si chaque sandbox utilise 512 MiB. Ce nombre passe à 3 si chaque sandbox utilise un gibioctet complet, après avoir réservé environ 1 GB pour le système d’exploitation, Docker et le daemon. Les sandboxes gelées sont limitées par le swap. Le fichier de swap de 16 GB créé par défaut par l’installateur peut donc conserver environ 16 sandboxes ayant chacune utilisé un gibioctet. Mesurez votre propre capacité avec free -m en charge réelle. Une sandbox qui exécute une suite de tests utilise plusieurs fois plus de mémoire qu’une sandbox qui exécute un petit script.

Pourquoi Dormice exige-t-il que vm.swappiness soit défini sur 100 ?

Geler une sandbox consiste à déplacer sa mémoire inactive vers le swap. gVisor conserve la mémoire de la sandbox sous forme de mémoire partagée. Avec la valeur par défaut de swappiness, le noyau Linux ne peut pas placer cette mémoire partagée dans le swap. Avec cette valeur, le gel ne libère donc aucune mémoire et la sandbox continue de consommer toute sa mémoire. Le projet a mesuré 0 octet récupéré avec la valeur par défaut, contre 99.5 pour cent avec la valeur 100. Vérifiez la valeur effective avec sysctl vm.swappiness au lieu de lire les fichiers de configuration, car certaines images cloud fournissent une valeur de 0.

Cet article vous a-t-il été utile ?