SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-10-21

Self-hosted Dormice का उपयोग करके agent sandbox कैसे बनाएं

अपने Linux VPS पर Dormice का उपयोग करके E2B-compatible agent sandbox सेटअप करें। यह गाइड आपको इंस्टॉलेशन, कोड आइसोलेशन और होस्ट साइजिंग की पूरी जानकारी प्रदान करती है।

Dormice क्या है, और क्या नहीं है

Dormice एक self-hosted agent sandbox है: यह आपके Linux VPS पर चलने वाला एक daemon है, जिसे आपका agent code HTTP के माध्यम से कॉल करता है ताकि एक isolated container के भीतर untrusted code चलाया जा सके। आपका प्रोग्राम नाम के आधार पर sandbox मांगता है, उसे वही sandbox वापस मिलता है (चाहे उसकी स्थिति कुछ भी हो), वह उसके भीतर एक command चलाता है, और output पढ़ता है। यह sandbox एक programmatic resource है, न कि कोई ऐसी मशीन जिसमें आप login करते हैं।

यह किसी agent को पूरा कंप्यूटर देने से बिल्कुल अलग है। एक coding agent के लिए throwaway VM एक ऐसा box है जिसमें आप SSH करते हैं, agent को उसे खराब करने देते हैं, और फिर उसे delete कर देते हैं। Dormice एक स्तर नीचे काम करता है: यह एक execution API है जिसे आपका प्रोग्राम तब कॉल करता है जब उसके पास पहले से code होता है और उसे चलाने के लिए एक सुरक्षित जगह की आवश्यकता होती है। जब काम की इकाई एक पूरी मशीन हो, तब throwaway VM का उपयोग करें। जब काम की इकाई एक single exec call हो, और आप बिना सौ VMs के दिन में सौ बार ऐसा करना चाहते हों, तब Dormice का उपयोग करें।

यह प्रोजेक्ट खुद को E2B compatible कहता है। E2B एक hosted sandbox service है जिसकी client library को कई agent frameworks पहले से ही import करते हैं। Dormice अपने स्वयं के URL prefixes के तहत उसी protocol को serve करता है, इसलिए आधिकारिक e2b package के लिए लिखा गया application तब भी चलता रहता है जब आप उसे अपने स्वयं के box की ओर point करते हैं। Application code में कोई बदलाव नहीं करना पड़ता। केवल दो URLs और एक API key prefix बदलते हैं।

"Agent sandboxes का SQLite" होने का व्यावहारिक अर्थ

SQLite एक ऐसा डेटाबेस है जिसे आप एम्बेड करते हैं, न कि कोई ऐसी सर्विस जिसे आप ऑपरेट करते हैं। Dormice इसी तुलना को सीधे अपनाता है। प्रति मशीन एक daemon, इसके लेजर के लिए एक SQLite फाइल, एक TCP port, और इसके साथ इंस्टॉल किया गया एक छोटा gateway जो वेब कंसोल सर्व करता है। इसमें न तो Kubernetes की आवश्यकता है और न ही किसी बाहरी डेटाबेस सर्वर की। Daemon अपने लेजर के साथ एक exclusive lock लेता है, इसलिए उसी मशीन पर दूसरा daemon चुपचाप state को विभाजित करने के बजाय स्टार्ट होने से मना कर देता है। प्रत्येक sandbox उसी मशीन पर रहता है जहाँ उसे बनाया गया था। README अब एक fleet को एक gateway और उसके प्राइवेट नेटवर्क पर मौजूद मशीनों के रूप में वर्णित करता है, लेकिन यह अभी भी कहता है कि यदि आपको ऐसी sandboxes की आवश्यकता है जो मशीनों के बीच मूव कर सकें, या अलग-अलग क्षेत्रों (regions) में फैली fleet चाहिए, तो आपको कुछ और चुनना चाहिए, और आपको इस सलाह पर ध्यान देना चाहिए।

इस विचार का दूसरा हिस्सा लागत के बारे में है। एक hosted sandbox अपने अस्तित्व के हर सेकंड के लिए बिल लेती है, इसलिए hosted sandboxes को डिज़ाइन के अनुसार ही डिस्पोजेबल (नष्ट करने योग्य) बनाया जाता है। Dormice उस हार्डवेयर पर चलता है जिसके लिए आप पहले से भुगतान कर रहे हैं, इसलिए इसकी sandboxes स्थायी होती हैं और जितना अधिक समय वे स्थिर रहती हैं, उतनी ही सस्ती होती जाती हैं। एक sandbox एक-एक करके ठंडी (cool down) होती है: active, फिर frozen, फिर stopped, और अंत में archived। कोई भी acquire कमांड इसे उस स्तर से वापस ऊपर ले आता है जहाँ तक वह पहुँची थी।

Freezing वह हिस्सा है जिसे समझना जरूरी है, क्योंकि यही वह चीज है जो हर एजेंट की sandbox को हमेशा के लिए किफायती बनाए रखती है। ये प्रोजेक्ट के अपने प्रकाशित आंकड़े हैं, जिन्हें इसके हार्डवेयर पर मापा गया है, न कि आपके हार्डवेयर पर।

चार्टOne idle sandbox before and after freezing, figures published by the project
इस चार्ट के पीछे का डेटा
[
  {
    "label": "Active, holding 1 GiB",
    "resident_memory_mib": 1024,
    "wake_ms": 0
  },
  {
    "label": "Frozen",
    "resident_memory_mib": 5,
    "wake_ms": 50
  }
]

1024 MiB मेमोरी वाली एक idle sandbox फ्रीज होने के बाद 5 MiB resident मेमोरी पर आ जाती है, और लगभग 50 ms में वापस सक्रिय हो जाती है। प्रक्रियाएं वहीं रुकती और फिर से शुरू होती हैं, इसलिए एक लंबे समय तक चलने वाला एजेंट फ्रीज के दौरान भी अपनी shell state और अपने अधूरे काम को सुरक्षित रखता है। इसके आधार पर क्षमता (capacity) की योजना बनाने से पहले इसे अपने स्वयं के होस्ट पर टेस्ट करें।

इंस्टॉलेशन से पहले होस्ट की आवश्यकताएं

होस्ट Ubuntu या Debian (x86_64) पर आधारित होना चाहिए और इंस्टॉलर को root एक्सेस की आवश्यकता होती है। डेमन (daemon) रनटाइम के दौरान root एक्सेस बनाए रखता है क्योंकि यह loop mounts करता है और cgroups में लिखता है।

सैंडबॉक्स (sandboxes) Docker के साथ gVisor (एक कंटेनर रनटाइम जो कंटेनर और होस्ट कर्नल के बीच एक userspace कर्नल रखता है) के अंतर्गत चलते हैं, जो प्रत्येक सैंडबॉक्स द्वारा उपयोग किए जाने वाले runsc रनटाइम को प्रदान करता है। डेमन को चलाने के लिए Node 22 या उससे नया वर्ज़न आवश्यक है। यदि आपके सिस्टम में Node 22 या उससे नया वर्ज़न पहले से मौजूद है, तो इंस्टॉलर उसी का उपयोग करता है; केवल तभी जब यह अनुपस्थित हो या पुराना हो, इंस्टॉलर अपनी एक निश्चित कॉपी डाउनलोड करता है, उसके चेकसम को सत्यापित करता है और उसे /opt के अंतर्गत अनपैक करता है।

Swap का होना अनिवार्य है और vm.swappiness का मान 100 होना चाहिए। यह ट्यूनिंग के लिए कोई सुझाव नहीं है, बल्कि एक कार्यात्मक आवश्यकता है। फ्रीजिंग (freezing) की प्रक्रिया एक निष्क्रिय सैंडबॉक्स की मेमोरी को swap में धकेल कर काम करती है। gVisor सैंडबॉक्स की मेमोरी को shared memory के रूप में रखता है, और कर्नल डिफ़ॉल्ट swappiness मान पर shared memory को swap नहीं करेगा। प्रोजेक्ट के मापन के अनुसार, डिफ़ॉल्ट मान पर 0 बाइट्स रिकवर हुए, जबकि 100 के मान पर 99.5 प्रतिशत मेमोरी रिकवर हुई। कर्नल वास्तव में किस मान का उपयोग कर रहा है, इसकी जाँच करें, क्योंकि कुछ क्लाउड इमेजेस में vm.swappiness = 0 एक ऐसी फाइल में होता है जिसे आप शायद कभी न पढ़ें।

sysctl vm.swappiness
swapon --show

sysctl vm.swappiness को vm.swappiness = 100 प्रिंट करना चाहिए, और swapon --show को एक swapfile की सूची दिखानी चाहिए। यदि swappiness 0 प्रिंट होता है, तो प्रत्येक फ्रीज एक निष्प्रभावी प्रक्रिया (no-op) होगी, जिसके कारण आपको प्रत्येक निष्क्रिय सैंडबॉक्स के लिए पूरी मेमोरी का भुगतान करना पड़ेगा।

Ubuntu पर Dormice इंस्टॉल करना

दस्तावेजीकृत इंस्टॉलेशन प्रक्रिया में bash में एक पाइप का उपयोग किया जाता है:

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

इसे चलाने से पहले इसे फेच करें और पढ़ें। यह स्क्रिप्ट root के रूप में चलती है और आपके host को पुनर्गठित करती है: यदि Docker मौजूद नहीं है तो यह उसे इंस्टॉल करती है, checksum सत्यापन के साथ gVisor और Caddy डाउनलोड करती है, यदि host पर swap नहीं है तो एक swapfile बनाती है, daemon, gateway और image registry के लिए systemd units लिखती है, और 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 swapfile का आकार निर्धारित करता है और इसका डिफ़ॉल्ट मान 16 है, जो एक छोटे VPS पर काफी अधिक डिस्क स्पेस ले सकता है। --mirror cn डाउनलोड को मुख्य भूमि चीन से पहुँच योग्य mirrors पर स्विच कर देता है। इंस्टॉलर को फिर से चलाने से कोड अपग्रेड होता है और drift ठीक हो जाता है, और यह कभी भी आपके API token को रोटेट नहीं करता है।

कोड /opt/dormice में, कॉन्फ़िगरेशन /etc/dormice/env में (gateway के लिए /etc/dormice/gateway.env के साथ), सैंडबॉक्स डेटा /var/lib/dormice में, और dormice तथा dor कमांड्स /usr/local/bin में जाते हैं। इंस्टॉलर इंस्टॉलेशन के दौरान API token उत्पन्न करता है और इसे 600 मोड के साथ /etc/dormice/env में लिखता है, और यही मान gateway की फाइल में भी जाता है।

इंस्टॉल करने के लिए कोई टैग किया गया release उपलब्ध नहीं है। 12 अक्टूबर 2026 तक रिपॉजिटरी में कोई git tags और कोई GitHub releases नहीं हैं, इसलिए इंस्टॉलर main को क्लोन करता है और आपको वह कोड मिलता है जो उस सुबह तक उपलब्ध था। इसलिए किसी version को पिन करने का अर्थ है उस commit को नोट करना जिसे आपने वास्तव में इंस्टॉल किया है।

git -C /opt/dormice rev-parse HEAD

उस hash को अपने deploy नोट्स के साथ सहेजें, क्योंकि यह आपको बताता है कि आप वास्तव में कौन सा कोड चला रहे हैं। यह अपने आप में वापस जाने का कोई तरीका नहीं है: नई प्रक्रियाएं बूट होते ही डेटाबेस माइग्रेशन लागू करती हैं, और अपग्रेड दस्तावेज़ कहते हैं कि पुराने इंस्टॉलर को फिर से चलाने से माइग्रेशन वापस नहीं होता है। किसी भी चीज़ को पुनरारंभ करने से पहले, इंस्टॉलर दोनों डेटाबेस के स्नैपशॉट /var/lib/dormice/backups/ में सहेजता है और तीन सबसे हालिया स्नैपशॉट रखता है। वे स्नैपशॉट एक खराब अपग्रेड के बाद वापस जाने का दस्तावेजीकृत तरीका हैं, इसलिए दोबारा अपग्रेड करने से पहले सबसे नए स्नैपशॉट को बॉक्स से बाहर कॉपी कर लें।

इंस्टॉलर dor doctor चलाकर समाप्त होता है, जो एक read-only host चेक है। यह यह साबित करने के लिए कि runtime काम कर रहा है, वास्तविक gVisor कंटेनर बूट करता है, बजाय इसके कि केवल पैकेज सूची पर भरोसा किया जाए। जब भी daemon ठीक से काम न करे, तो इसे फिर से चलाएं।

sudo dor doctor
systemctl is-active dormice

systemctl is-active dormice को active प्रिंट करना चाहिए। यदि यह failed प्रिंट करता है, तो journalctl -u dormice -n 50 में कारण मौजूद होता है, और एक विफल स्टार्ट आमतौर पर daemon के बजाय swap या gVisor की पूर्व-आवश्यकता (prerequisite) से संबंधित होता है।

इंस्टॉलर बॉक्स पर Caddy भी डालता है, इसलिए यह तय करने से पहले कि firewall का काम पूरा हो गया है, देखें कि कौन सा पोर्ट listening है।

sudo ss -lntp

daemon हमेशा 127.0.0.1 पर bind होता है, और डिज़ाइन के अनुसार उस पते को बदलने के लिए कोई सेटिंग नहीं है। केवल पोर्ट बदलता है: DORMICE_PORT का डिफ़ॉल्ट मान 3676 है। इसके बगल में स्थित gateway 127.0.0.1:3677 पर उसी नियम का पालन करता है, जिसमें पोर्ट के लिए DORMICE_GATEWAY_PORT है और जानबूझकर कोई host सेटिंग नहीं है। अपने लैपटॉप से किसी तक पहुँचना एक सचेत कार्य है, और इसका सस्ता संस्करण एक SSH टनल है जो दोनों पोर्ट्स को फॉरवर्ड करता है।

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

टनल खुलने के बाद, आपके लैपटॉप पर http://127.0.0.1:3677/console वेब कंसोल है, जिसे gateway द्वारा सर्व किया जाता है। अपनी पहली विजिट पर आप एक बार API token पेस्ट करके यह साबित करते हैं कि आप ऑपरेटर हैं, फिर एक कंसोल उपयोगकर्ता नाम और पासवर्ड सेट करते हैं। साइन इन करने पर एक httpOnly सेशन कुकी सेट होती है, जो 7 दिनों के लिए वैध होती है, जिसे पेज JavaScript नहीं पढ़ सकता है, और कंसोल कभी भी token को वापस प्रदर्शित नहीं करता है। वहां मौजूद Connect पेज आपके अपने endpoint पर पहले से पॉइंट किए गए copy-and-paste क्लाइंट स्निपेट्स प्रिंट करता है।

सैंडबॉक्स बनाएँ और उसमें कोड निष्पादित करें

सैंडबॉक्स बनाने के लिए एक ही ऑपरेशन है: acquire। यह idempotent है, इसलिए एक ही key हमेशा एक ही सैंडबॉक्स लौटाती है, जिसे आवश्यकतानुसार बनाया, जगाया, शुरू या रिस्टोर किया जाता है। अन्य सभी वर्ब किसी ऐसी key के लिए 404 त्रुटि देते हैं जिसे उन्होंने पहले कभी नहीं देखा है। dor CLI में कोई acquire वर्ब नहीं है, इसलिए आपका पहला सैंडबॉक्स कंसोल या क्लाइंट लाइब्रेरी से आता है।

कंसोल रूट सबसे तेज़ है। टनल के माध्यम से /console खोलें और my-agent नाम का एक सैंडबॉक्स बनाएँ। इसके बाद CLI उस पर काम करने लगता है।

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 प्रत्येक सैंडबॉक्स को उसकी लाइफसाइकिल स्थिति के साथ सूचीबद्ध करता है, जिससे आप देख सकते हैं कि कोई सैंडबॉक्स active से frozen स्थिति में कैसे आता है। dor sandbox exec Python 3.12 वर्ज़न प्रिंट करता है, क्योंकि स्टॉक इमेज Ubuntu 24.04 है जिसमें Python 3.12, Node 24, git और ripgrep पहले से इंस्टॉल हैं। यदि प्रमाणीकरण त्रुटि (authentication error) आती है, तो इसका मतलब है कि आपके द्वारा कॉपी की गई टोकन लाइन में वेरिएबल का नाम भी शामिल था।

फाइलें dor sandbox push my-agent ./script.py के साथ मूव होती हैं, जो /home/user/script.py पर पहुँचती हैं, और dor sandbox pull my-agent notes.txt उन्हें वापस लाता है। नेटिव फाइल वर्ब्स की सीमा 16 MiB प्रति फाइल है, जबकि E2B फाइल सरफेस स्ट्रीम करती है और सैंडबॉक्स डिस्क कोटा को ही एकमात्र सीमा रहने देती है।

डिस्ट्रॉय करना ही एकमात्र ऐसा वर्ब है जिससे डेटा नष्ट होता है। dor sandbox destroy my-agent सैंडबॉक्स को हटा देता है और यह idempotent है। मुख्य README, बंडल की गई एजेंट स्किल और CLI पैकेज README, सभी इसे इसी एक नाम के अंतर्गत डॉक्यूमेंट करते हैं। अपने स्वयं के बिल्ड पर dor sandbox --help चलाएँ, क्योंकि इंस्टॉलर main को ट्रैक करता है और CLI का आकार लगातार बढ़ रहा है।

अपने मौजूदा E2B कोड को अपने स्वयं के बॉक्स पर पॉइंट करें

यही वह कारण है जिसकी वजह से आपको इसकी परवाह करनी चाहिए। npm से प्राप्त आधिकारिक e2b पैकेज, बिना किसी बदलाव के, Dormice से बात करता है। इसे अपने लैपटॉप से SSH टनल खुले रहने के दौरान चलाएं, ताकि सर्वर पर कोई भी नई चीज़ listen न करे।

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

एक सफल रन exit code 0 और 42 प्रिंट करता है। API key आपका Dormice टोकन है जिसके आगे e2b_ उपसर्ग लगा है, जो कि वह प्रारूप है जिसकी compatibility layer अपेक्षा करती है।

यह compatibility कोई स्टब नहीं है। स्ट्रीमिंग stdout और stderr, बैकग्राउंड कमांड, एक इंटरैक्टिव PTY, हस्ताक्षरित अपलोड और डाउनलोड URL, डायरेक्टरी वाचिंग और एक पोर्ट प्रॉक्सी, ये सभी आधिकारिक पैकेज के माध्यम से एक वास्तविक Docker और gVisor डेमन पर प्रोजेक्ट के एंड-टू-एंड सूट द्वारा उपयोग किए जाते हैं। किसी भी वास्तविक चीज़ को माइग्रेट करने से पहले कुछ अंतरों पर ध्यान देना आवश्यक है:

  • टेम्पलेट बिल्ड लागू नहीं किए गए हैं। एक टेम्पलेट वह docker इमेज है जिसे आप स्वयं बनाते हैं और dor template add के साथ रजिस्टर करते हैं, और Sandbox.create('name') इसे रिज़ॉल्व करता है। एक अपंजीकृत नाम होने पर यह बहाना बनाने के बजाय 404 त्रुटि देता है।
  • E2B इंटरफेस के माध्यम से बनाए गए सैंडबॉक्स को वास्तविक समय-सीमा (deadlines) मिलती है, क्योंकि E2B सिमेंटिक्स के लिए उनकी आवश्यकता होती है। नेटिव API के माध्यम से बनाए गए सैंडबॉक्स पर कभी भी समय-सीमा लागू नहीं की जाती है।
  • एक फ्रोजन सैंडबॉक्स अपनी प्रक्रियाओं को बनाए रखता है और उन्हें बीच से ही फिर से शुरू करता है, इसलिए यहाँ पॉज़ और रिज़्यूम वह स्टॉप और कोल्ड स्टार्ट नहीं है जिसके आप आदी हो सकते हैं।

सैंडबॉक्स क्या रोकता है और क्या नहीं

gVisor कंटेनर के सिस्टम कॉल्स को userspace में इंटरसेप्ट करता है और उन्हें खुद प्रोसेस करता है, इसलिए सैंडबॉक्स में चल रहा कोड सीधे आपके होस्ट कर्नल से बात नहीं करता है। सैंडबॉक्स के अंदर, कमांड्स user (uid 1000) के रूप में चलते हैं, लेकिन उस अकाउंट के पास पासवर्ड-रहित sudo होता है, इसलिए सैंडबॉक्स के अंदर root एक्सेस किसी भी ऐसे कोड के लिए उपलब्ध है जो इसकी मांग करता है। uid को सुरक्षा न मानें: प्रोजेक्ट स्पष्ट रूप से कहता है कि सुरक्षा सीमा gVisor है, न कि uid, और एक सैंडबॉक्स जो खुद को elevate करता है, वह भी होस्ट कर्नल तक नहीं पहुँच सकता। यह सामान्य मामलों को संभाल लेता है: एक जनरेटेड स्क्रिप्ट जो rm -rf / चलाती है, डिस्क भरती है, या तब तक फोर्क (fork) करती है जब तक कुछ क्रैश न हो जाए, वह केवल अपने सैंडबॉक्स को नुकसान पहुँचाती है और वहीं रुक जाती है।

यहाँ वह है जिसे यह नहीं रोकता है। इनमें से प्रत्येक आपकी जिम्मेदारी है।

  • सैंडबॉक्स में आउटबाउंड नेटवर्क काम करता है। जनरेटेड कोड जो चाहे डाउनलोड कर सकता है और जो भी उसे मिलता है उसे पोस्ट कर सकता है। इंस्टॉलर की नेटवर्क हार्डनिंग दो विशिष्ट चीजों को कवर करती है: यह 169.254.0.0/16 और 100.100.100.200 (Alibaba Cloud का पता) पर क्लाउड मेटाडेटा सर्विस के लिए कंटेनर ट्रैफिक को ड्रॉप करती है, जहाँ से क्लाउड इंस्टेंस क्रेडेंशियल्स किसी भी ऐसी चीज़ को मिल सकते हैं जो वहाँ तक पहुँच सके, और यह Docker के daemon.json में "icc": false के साथ कंटेनर-टू-कंटेनर ट्रैफिक को बंद कर देती है। इसके अलावा कुछ भी ब्लॉक नहीं है। sudo iptables -S DOCKER-USER पढ़ें और उन प्राइवेट रेंज के लिए अपने स्वयं के DROP रूल्स जोड़ें जहाँ सैंडबॉक्स को पहुँचने की आवश्यकता नहीं है।
  • Docker आपके फायरवॉल से पहले अपने स्वयं के रूल्स डाल देता है, इसलिए एक पब्लिश्ड कंटेनर पोर्ट इंटरनेट से रिस्पॉन्स दे सकता है, जबकि ufw यह दिखाएगा कि वह बंद है। किसी भी चीज़ को इस होस्ट पर एक्सपोज़ करने से पहले Docker द्वारा ufw के ऊपर पोर्ट पब्लिश करने का तरीका और VPS के लिए ufw फायरवॉल की बुनियादी जानकारी पढ़ें।
  • gVisor एक userspace कर्नल है, न कि हाइपरवाइजर। यह एक जानबूझकर किया गया समझौता है, क्योंकि फ्रीजिंग के लिए सैंडबॉक्स का प्रोसेस होना आवश्यक है, और KVM की आवश्यकता इसे कहीं भी इंस्टॉल होने से रोक देगी। यदि आपका थ्रेट मॉडल हार्डवेयर वर्चुअलाइजेशन की मांग करता है, तो Firecracker-क्लास आइसोलेशन का उपयोग करें और इसके साथ आने वाली परिचालन लागत को स्वीकार करें।
  • क्लाइंट साइड पर API टोकन ही पूरी सुरक्षा सीमा है। जिसके पास DORMICE_API_TOKEN है, वह मशीन पर हर सैंडबॉक्स को बना, पढ़ और नष्ट कर सकता है। एजेंट प्रोसेस को अपना VPS पर न्यूनतम विशेषाधिकार वाला यूजर दें और टोकन के साथ वैसा ही व्यवहार करें जैसा आप SSH की (key) के साथ करते हैं। VPS पर सुरक्षित रूप से Claude Code चलाने की आदतें यहाँ सीधे लागू होती हैं।

डेमन खुद आपके होस्ट पर root के रूप में चलता है। gVisor होस्ट को सैंडबॉक्स के अंदर के कोड से बचाता है, और डेमन या उसके टोकन को रखने वाले किसी भी व्यक्ति से होस्ट को बचाने के लिए कुछ भी नहीं है। इसलिए Dormice चलाने वाली मशीन को केवल वही काम करना चाहिए। यदि आपका एजेंट MCP (model context protocol) के माध्यम से टूल्स तक भी पहुँचता है, तो उसी कारण से उन MCP सर्वर्स को एक अलग VPS पर रखें।

4 GB और 8 GB में कितने सैंडबॉक्स समा सकते हैं?

मेमोरी मुख्य रूप से दो चीजों द्वारा खपत होती है: होस्ट का अपना बेसलाइन, और वर्तमान में सक्रिय प्रत्येक सैंडबॉक्स का वर्किंग सेट। Ubuntu, Docker और डेमन के लिए लगभग 1 GB सुरक्षित रखें, फिर शेष मेमोरी को एक सैंडबॉक्स द्वारा वास्तव में उपयोग की जाने वाली मेमोरी से विभाजित करें। एक Python स्क्रिप्ट चलाने वाला सैंडबॉक्स जो कुछ फाइलें पढ़ता है, वह लगभग 200 से 300 MiB के आसपास रहता है। कंपाइलर या पूर्ण टेस्ट सुइट चलाने वाला सैंडबॉक्स एक gibibyte से अधिक ले सकता है।

चार्टConcurrent sandboxes by host RAM, arithmetic after a 1 GB host reserve
इस चार्ट के पीछे का डेटा
[
  {
    "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
  }
]

एक 4 GB VPS एक साथ 6 सैंडबॉक्स को सक्रिय रख सकता है यदि प्रत्येक 512 MiB का उपयोग करता है, या 3 यदि प्रत्येक एक पूर्ण gibibyte का उपयोग करता है। एक 8 GB VPS इसे 14 और 7 तक ले जाता है। ये समवर्ती कार्य के लिए अधिकतम सीमाएं हैं, और ये बेंचमार्क के बजाय गणितीय गणना हैं, इसलिए अपना लोड चलाते समय free -m पर नज़र रखें।

फ्रोजन सैंडबॉक्स RAM के बजाय स्वैप (swap) द्वारा सीमित होते हैं, जो इस डिज़ाइन का मुख्य उद्देश्य है। एक फ्रोजन सैंडबॉक्स जो एक gibibyte का उपयोग कर रहा था, वह लगभग उतनी ही मात्रा स्वैप में रखता है और RAM में लगभग कुछ भी नहीं, इसलिए इंस्टॉलर की डिफ़ॉल्ट 16 GB स्वैपफाइल उनमें से लगभग 16 को पार्क कर सकती है। इसके बाद उन्हें 'stopped' स्थिति में जाने की आवश्यकता होती है, जहाँ वे केवल डिस्क स्पेस लेते हैं। यहाँ डिस्क ही वास्तविक दीर्घकालिक सीमा है: प्रत्येक सैंडबॉक्स अपना फाइलसिस्टम रखता है, और कुछ दर्जन एजेंट्स, जिनमें से प्रत्येक में node_modules डायरेक्टरी होती है, मेमोरी के महत्वपूर्ण होने से बहुत पहले ही एक छोटी वॉल्यूम को भर देंगे।

Freeze, stop, archive: lifecycle knobs

डिफ़ॉल्ट रूप से, 10 मिनट तक idle रहने पर freeze, 3 दिन बाद stop, और यदि archiving कॉन्फ़िगर की गई है तो 7 दिन बाद archive करने की प्रक्रिया होती है। stopAfterSeconds को null पर सेट करने से आपको एक resident agent मिलता है: यह idle होने पर freeze हो सकता है, लेकिन यह कभी भी cold start नहीं होता।

Archiving वैकल्पिक है, और daemon इस बारे में स्पष्ट रहता है। Console के settings पेज पर S3-compatible store कॉन्फ़िगर करें (चार DORMICE_S3_* variables अभी भी मौजूद हैं, लेकिन वे केवल gateway के पहले boot के लिए seeds के रूप में कार्य करते हैं)। इसके बाद, एक stopped sandbox की disk को tar और zstd के साथ पैक किया जाता है, bucket में भेजा जाता है, और स्थानीय स्तर पर मुक्त कर दिया जाता है। वह bucket आपके द्वारा किसी अन्य मशीन पर होस्ट किया गया MinIO bucket हो सकता है। यदि store को कॉन्फ़िगर नहीं किया जाता है, तो sandboxes हमेशा के लिए stopped स्थिति में रहते हैं, और archive करने की policy को चुपचाप अनदेखा करने के बजाय अस्वीकार कर दिया जाता है। Restores चुपचाप होने के बजाय दिखाई देते हैं: अगला acquire तुरंत एक restoring status और progress value के साथ उत्तर देता है, और disk वापस आने पर ready स्थिति में बदल जाता है।

क्या आपको अभी इस पर निर्भर रहना चाहिए?

सीधा जवाब: ऐसी किसी भी चीज़ के लिए नहीं जिसे आप फिर से न बना सकें। यह रिपॉजिटरी 8 July 2026 को बनाई गई थी। 12 October 2026 तक इसमें 1,509 stars, 109 forks और Apache-2.0 लाइसेंस है, लेकिन कोई भी tagged release नहीं है। README की अपनी स्टेटस लाइन कहती है कि यहाँ कुछ भी production के लिए तैयार नहीं है।

इस संयोजन में जोखिम का एक विशिष्ट स्वरूप है। कोड आपके नियंत्रण के बिना बदलता रहता है, क्योंकि इंस्टॉलर main को ट्रैक करता है। इंटरफ़ेस अभी भी स्थिर हो रहा है: दस्तावेज़ अब डेमन (daemon) के सामने एक गेटवे का वर्णन करते हैं, जिसका अपना पोर्ट, अपनी कॉन्फ़िगरेशन फ़ाइल और अपना डेटाबेस है। और लगभग तीन महीने पुराना प्रोजेक्ट बस बंद हो सकता है, क्योंकि कोई भी लाइसेंस क्लॉज किसी को इसे जारी रखने के लिए बाध्य नहीं करता है।

जो जोखिम को सहने योग्य बनाता है वह E2B संगतता (compatibility) है। आपका एप्लिकेशन एक ऐसे प्रोटोकॉल से बात करता है जिसके पीछे एक होस्टेड कार्यान्वयन है, इसलिए यदि Dormice रुक जाता है, तो आप दो URL बदलें और काम जारी रखें। अपने एजेंट को नेटिव API के बजाय E2B इंटरफ़ेस के विरुद्ध लिखें और आप उस निकास मार्ग (exit) को बनाए रखेंगे। नेटिव @dormice/sdk पैकेज अभी तक npm पर भी नहीं है, इसलिए इसका उपयोग करने का मतलब है इसे रिपॉजिटरी से बनाना, जो संगत पथ (compatible path) के साथ शुरुआत करने का दूसरा कारण है।

इसे वहाँ चलाएँ जहाँ आप इसे खोने का जोखिम उठा सकें। होस्ट को स्क्रिप्ट से फिर से बनाएँ, टोकन को हर प्रॉम्प्ट और हर कमिट से बाहर रखें, और जो कुछ भी रखने लायक है उसे अपने बैकअप शेड्यूल पर सैंडबॉक्स से बाहर निकालें।

FAQ

क्या Dormice प्रोडक्शन के लिए तैयार है?

नहीं, और प्रोजेक्ट स्वयं भी यही कहता है। README की स्टेटस लाइन बताती है कि वहां मौजूद कोई भी चीज़ अभी प्रोडक्शन के लिए तैयार नहीं है, और 12 October 2026 तक यह रिपॉजिटरी लगभग तीन महीने पुरानी है जिसमें कोई git tags और कोई releases नहीं हैं, इसलिए पिन करने के लिए कोई वर्शन नंबर मौजूद नहीं है। इंस्टॉलर main ब्रांच को क्लोन करता है, जिसका अर्थ है कि प्रत्येक रन आपको सबसे नया कमिट देता है। हर इंस्टॉलेशन के बाद git -C /opt/dormice rev-parse HEAD रिकॉर्ड करें, इंस्टॉलर द्वारा /var/lib/dormice/backups/ में लिखे गए डेटाबेस स्नैपशॉट्स की एक कॉपी रखें, और किसी भी मूल्यवान चीज़ को सैंडबॉक्स के बाहर रखें।

Dormice मेरे एजेंट को एक डिस्पोजेबल VM देने से कैसे अलग है?

डिस्पोजेबल VM एक ऐसी मशीन है जिसमें SSH होता है जिसे आप एक सेशन के लिए बनाते हैं और बाद में डिलीट कर देते हैं। Dormice एक एक्जीक्यूशन API है: आपका प्रोग्राम acquire, फिर exec कॉल करता है, और बीच में किसी शेल सेशन के बिना stdout और एक एग्जिट कोड प्राप्त करता है। VM उस इंसान या एजेंट के लिए उपयुक्त है जो कुछ समय के लिए पूरा कंप्यूटर चाहता है। Dormice उस एप्लिकेशन के लिए उपयुक्त है जो दिन में कई बार जेनरेट किया गया कोड चलाती है और प्रत्येक रन के लिए मशीन के सेटअप और टियरडाउन की आवश्यकता नहीं चाहती है।

क्या आधिकारिक E2B SDK वास्तव में बिना कोड बदले काम करता है?

हाँ, कॉन्फ़िगरेशन में बदलाव के साथ। apiUrl और sandboxUrl को अपने डेमन पर /e2b/api और /e2b/envd पर पॉइंट करें, और अपने Dormice टोकन को e2b_ प्रीफिक्स के साथ API की के रूप में पास करें। कमांड एक्जीक्यूशन, PTY सेशन, फाइल ट्रांसफर, साइन्ड URL और पोर्ट प्रॉक्सी, ये सभी आधिकारिक पैकेज के माध्यम से चलने वाले प्रोजेक्ट के एंड-टू-एंड सूट द्वारा कवर किए जाते हैं। टेम्पलेट बिल्डिंग एक उल्लेखनीय अंतर है: e2b template build लागू नहीं है, इसलिए एक टेम्पलेट वह डॉकर इमेज है जिसे आप बनाते हैं और dor template add के साथ रजिस्टर करते हैं।

4 GB VPS पर कितने सैंडबॉक्स फिट हो सकते हैं?

यदि प्रत्येक सैंडबॉक्स 512 MiB का उपयोग करता है, तो एक ही समय में लगभग 6 सक्रिय रह सकते हैं, या यदि प्रत्येक एक पूरा gibibyte उपयोग करता है, तो 3 सक्रिय रह सकते हैं, ऑपरेटिंग सिस्टम, Docker और डेमन के लिए लगभग 1 GB आरक्षित करने के बाद। फ्रोजन सैंडबॉक्स की सीमा स्वैप द्वारा तय होती है, इसलिए इंस्टॉलर की डिफ़ॉल्ट 16 GB स्वैपफाइल लगभग 16 सैंडबॉक्स को पार्क करती है, जिनमें से प्रत्येक एक gibibyte रखता है। वास्तविक लोड के तहत free -m के साथ अपना माप स्वयं लें, क्योंकि टेस्ट सूट चलाने वाला सैंडबॉक्स एक छोटा स्क्रिप्ट चलाने वाले सैंडबॉक्स की तुलना में कई गुना अधिक मेमोरी का उपयोग करता है।

Dormice को vm.swappiness को 100 पर सेट करने की आवश्यकता क्यों है?

सैंडबॉक्स को फ्रीज करने का अर्थ है इसकी आइडल मेमोरी को स्वैप में धकेलना। gVisor सैंडबॉक्स मेमोरी को शेयर्ड मेमोरी के रूप में रखता है, और Linux कर्नल डिफ़ॉल्ट स्वैपनेस पर शेयर्ड मेमोरी को स्वैप नहीं करेगा, इसलिए डिफ़ॉल्ट पर फ्रीज करने से कुछ भी वापस नहीं मिलता है और सैंडबॉक्स पूरी मेमोरी की लागत लेता रहता है। प्रोजेक्ट ने डिफ़ॉल्ट पर 0 बाइट्स रिकलेम और 100 पर 99.5 प्रतिशत रिकलेम मापा है। कॉन्फ़िगरेशन फाइलों को पढ़ने के बजाय sysctl vm.swappiness के साथ प्रभावी मान की जाँच करें, क्योंकि कुछ क्लाउड इमेजेज 0 का मान शिप करती हैं।

क्या यह लेख उपयोगी था?