यह गाइड बताता है कि कंटेनर, माइक्रो वर्चुअल मशीन और भविष्य के विकल्पों का उपयोग करके Python में AI एजेंट द्वारा निष्पादित कोड को कैसे सैंडबॉक्स किया जाए।
यह गाइड AI एजेंट Python कोड के लिए उपप्रक्रिया, Docker और फायरक्रैकर सैंडबॉक्स की तुलना करता है, छह हमलों, विलंबता लागत और व्यापार-ऑफ को मापता है।
मुख्य जानकारी
- यह लेख बताता है कि एक एकल `run_ Python 'उपकरण के पीछे एआई-एजेंट द्वारा उत्पन्न Python -कोड को कैसे सैंडबॉक्स किया जाए, जिसमें विनिमेय बैकेंड्सः उपप्रक्रिया, Docker और फायरक्रैकर माइक्रोवीएम शामिल हैं।
- उप-प्रक्रिया सैंडबॉक्सिंग सबसे तेज़ स्तर है, जो संसाधन सीमाओं का उपयोग करता है, अस्थायी निर्देशिकाओं को अलग कर देता है, विशेषाधिकारों को छोड़ देता है और निजी नेटवर्क नामस्थान, लेकिन अभी भी होस्ट कर्नेल और फ़ाइल सिस्टम साझा करता है।
- Docker कंटेनर cgroups, नामस्थानों के माध्यम से मजबूत अलगाव प्रदान करते हैं, केवल-पढ़ने योग्य फ़ाइल सिस्टम, क्षमताओं को छोड़ दिया गया है और स्पष्ट नेटवर्क सीमाएं हैं, हालांकि वे कंटेनर पलायन के लिए असुरक्षित रहते हैं।
- फायरक्रैकर/ई2बी माइक्रोवीएम प्रत्येक निष्पादन को एक हाइपरवाइज़र के पीछे अपना कर्नेल देकर सबसे मजबूत सीमा प्रदान करते हैं, जो उच्च विलंबता की कीमत पर सुरक्षा में सुधार करता है।
- गाइड छह शत्रुतापूर्ण कार्यक्रमों का परीक्षण करता है और बेंचमार्क विलंबता को यह दिखाने के लिए कि अलगाव की ताकत सुरक्षा और प्रदर्शन दोनों को कैसे प्रभावित करती है।
मेटा विवरणः AI एजेंट कोड के लिए उप-प्रक्रिया, Docker और फायरक्रैकर माइक्रोवीएम सैंडबॉक्स की तुलना करें, छह हमलों का परीक्षण करें और प्रत्येक अलगाव स्तर के लिए विलंबता लागत को मापें।
टैगः AI एजेंट, कोड सैंडबॉक्सिंग, Docker , पटाखा, सुरक्षा
AI एजेंट कोड निष्पादन के लिए तीन सैंडबॉक्स स्तरों का सार मैत्रीपूर्ण चित्रणः एक उपप्रक्रिया, Docker कंटेनर और फायरक्रैकर माइक्रोवीएम।
यह उन डेवलपर्स के लिए है जो Python कोड लिखते हैं और फिर इसे निष्पादित करते हैं। इसमें दिखाया गया है कि एक रन_ Python टूल के पीछे AI एजेंट कोड को सैंडबॉक्स कैसे किया जाए, जिसमें तीन विनिमेय बैकएंड्स हैंः एक सीमित उपप्रक्रिया, एक कठोर Docker कंटेनर और ई 2 बी फायरक्रैकर माइक्रोवीएम। समान छह शत्रुतापूर्ण कार्यक्रम प्रत्येक स्तर का परीक्षण करते हैं, और विलंबता बेंचमार्क से पता चलता है कि मजबूत अलगाव की लागत क्या है।
एक उपकरण और तीन बैकएंड
एजेंट एक एकल रन_ Python टूल को उजागर करता है। प्रत्येक कॉल सैंडबॉक्स ऑब्जेक्ट से गुजरता है, इसलिए स्विचिंग लेयर्स के लिए एजेंट लूप बदलने की आवश्यकता नहीं होती है। उपकरण विवरण मॉडल को बताता है कि run_ Python कोड का एक स्ट्रिंग लेता है और stdout, stderr और एक निकास कोड देता है। लूप वार्तालाप को आगे भेजता है और जब मॉडल टूल का अनुरोध करता है, तो कोड sandbox.run पर जाता है। परिणाम tool_result के रूप में लौटाया जाता है, जब भी बाहर निकलने वाला कोड शून्य नहीं होता है तब इसे त्रुटि के तौर पर चिह्नित किया जाता है. मॉडल का कोड कभी भी मुख्य प्रक्रिया के अंदर नहीं चलता है। कोई भी वस्तु जो ((रनकोड) विधि के साथ हो सकती है वह The Sandbox की तरह काम कर सकती है।
प्रारंभ करने के लिए, Python 3.10 या नए का उपयोग करें. उप-प्रक्रिया स्तर Linux संसाधन सीमाओं पर निर्भर करता है और अनशेयर करता है, इसलिए इसे Linux या WSL में चलाएं। एजेंट लूप और E2B माइक्रोवीएम के लिए आवश्यक एसडीके स्थापित करें. पहले रन से पहले Docker कंटेनर इमेज खींचें ताकि पहला परीक्षण डाउनलोड को शामिल न करे. ई 2 बी खाते और API कुंजी, साथ ही Anthropic API कुंजी को वातावरण में स्टोर करें; यदि आप सीधे परीक्षणों पर जाना चाहते हैं तो एजेंट चक्र को छोड़ दिया जा सकता है. एक फ़ोल्डर में चार फाइल रखें: sandbox.py, agent.py , attacks.py और bench.py. Define Result साझा रिटर्न प्रकार, ट्रिम आउटपुट के रूप में, और SAFE_VEN का उपयोग करके API कुंजियों और होम डायरेक्टरी को छोड़ दें.
अविश्वसनीय कोड संसाधनों का उपभोग कर सकता है, रहस्य पढ़ सकते हैं, आंतरिक सेवाओं को बुला सकते हैं या अपनी सीमा से बच सकते हैं। तीन स्तर अलग-अलग होते हैं जहां वह सीमा बैठती है। एक सबप्रोसेस सबसे हल्का विकल्प हैः CPU, मेमोरी और फ़ाइल आकार पर सीमाओं के साथ एक चाइल्ड प्रोसेस, लेकिन यह अभी भी होस्ट कर्नेल और फाइलों को साझा करता है। कंटेनर नेमस्पेस और सीग्रुप जोड़ता है, फिर भी यह होस्ट कर्नल पर प्रक्रियाओं का एक सेट बना रहता है। Docker प्रलेखन चेतावनी देता है कि जब तक आप उन्हें निर्धारित नहीं करते तब तक कंटेनर्स में कोई संसाधन सीमाएं नहीं होती हैं। भाग जाता है: नवंबर 2025 में, तीन रन भेद्यताओं ने हमलावरों को कन्टेनर से बाहर निकलने दिया। माइक्रोवीएम प्रत्येक सैंडबॉक्स को हाइपरवाइज़र के पीछे अपना स्वयं का कर्नेਲ देता है।
सीमित उपप्रक्रिया सबसे तेज़ सीमा है
उप-प्रक्रिया बैकएंड में, _apply_limits कोड शुरू होने से पहले बच्चे के अंदर चलता है। यह CPU समय को कैप करता है, पता स्थान के रूप में मेमोरी और किसी भी फ़ाइल का आकार जो कोड लिखता है। यदि The Sandbox रूट के तौर पर चलाया जाता है, तो यह सबसे पहले अनप्राइवेटेड कोई नहीं उपयोगकर्ता तक गिरता है, रूट की पूरक समूहों को साफ़ करता है और एक प्रक्रिया सीमा जोड़ता है. वह सीमा एक उपयोगकर्ता से संबंधित सभी प्रक्रियाओं को गिनती करती है, इसलिए यह केवल समर्पित उपयोगकर्ता के लिए समझ में आता है। सामान्य laptop पर, प्रक्रिया टोपी छोड़ दी जाती है।
रन विधि एक ताजा अस्थायी फ़ोल्डर बनाती है और उस फोल्डर के अंदर अलग-थलग मोड में Python -I निष्पादित करती है। कमांड unshare --net में लपेटा जाता है, जो बच्चे को इसमें कुछ भी नहीं के साथ एक निजी नेटवर्क देता है. कंस्ट्रक्टर जांचता है कि अनशेयर काम करता है और यदि ऐसा नहीं होता है तो त्रुटि उठाता है, इसलिए The Sandbox कभी भी चुपचाप खुले नेटवर्क पर वापस नहीं आता है। आउटपुट फ़ाइलों में लिखा गया है, जिसका अर्थ है फाइल-आकार की सीमा प्रिंट बाढ़ को भी रोकती है। टाइमआउट पूरे प्रक्रिया समूह को मारता है और बाद में अस्थाई फ़ोल्डर हटा दिया जाता है। यह परत आपकी फ़ाइलों को छिपाती नहीं हैः कोड आपके रूप में चलता है, आपके फ़ाइल सिस्टम पर।
Docker और माइक्रोवीएम अलगाव जोड़ें
Docker बैकएंड एक कमांड चलाता है जहां प्रत्येक फ्लैग एक दरवाजा बंद कर देता है. --नेटवर्क कोई भी नेटवर्क एक्सेस को हटा नहीं सकता। --केवल-पढ़ने वाला रूट फाइल सिस्टम अलिखित बनाता है, जबकि छोटा 16 MB /tmp स्क्रैच स्पेस प्रदान करता है। --कैप ड्रॉप ऑल और नो-न्यू-प्राइवलिज विशेष विशेषाधिकारों को हटाते हैं, और उपयोगकर्ता रूट के रूप में चलाने से बचते हैं। संसाधन झंडे Docker के प्रलेखित नियंत्रणों का पालन करते हैंः -मेमोरी प्लस एक बराबर मेमोरी-स्वैप कंटेनर को स्वैप का उपयोग करने से रोकता है, और cpus और pids-limit cap CPU और प्रक्रिया गिनती कार्यक्रम stdin पर आता है, इसलिए कोई मेजबान फ़ोल्डर माउंट नहीं किया गया है। टाइमआउट पर, Docker कंटेनر को मारना बंद हो जाता है, क्योंकि 885000 क्लाइंट को अकेले मारने से कन्टेनर चलता रहेगा।
ई 2 बी बैकएंड फायरक्रैकर माइक्रोवीएम को लपेटता है। E2BSandbox प्रत्येक रन के लिए एक नया सैंडबॉक्स बनाता है, इसलिए निष्पादनों के बीच कुछ भी नहीं होता है। ब्लॉक VM को नष्ट कर देता है जब रन समाप्त हो जाता है। run_code लॉग और त्रुटि ऑब्जेक्ट लौटाता है, प्रति ई 2 B SDK संदर्भ, और उन मूल्यों को उसी परिणाम प्रकार में कॉपी किया जाता है. यदि कोड अपने टाइमआउट से अधिक है, तो SDK एक अपवाद उठाता है जिसे बैकएन्ड टाइम्ड_आउट में परिवर्तित करता है। get_backend हेल्पर नाम द्वारा स्तर चुनता है
संदर्भ के लिए, Docker ने अप्रैल 2026, में माइक्रोवीएम पर Docker Sandboxes लॉन्च किया और AWS लैम्ब्डा माइक्रोवीएम्स की पेशकश करता है, जो 8 घंटे तक राज्य रखते हैं और निष्क्रिय होने पर निलंबित हो जाते हैं। लेखक की अपेक्षा, पूर्वानुमान के बजाय राय के रूप में बताई गई है, यह है कि एजेंट कोड के लिए डिफ़ॉल्ट सीमा बन सकती है, जिसमें नीति मॉडल के बजाय बुनियादी ढांचे द्वारा निर्धारित होती है।
तीन स्तरों का परीक्षण और तुलना करें
हमले की स्क्रिप्ट एक नकली क्रेडेंशियल्स फ़ाइल डालती है और आंतरिक सेवा के लिए स्टैंड-इन के रूप में मेजबान के लूपबैक इंटरफेस पर एक श्रोता शुरू करती है। प्रत्येक हमला एक प्रोग्राम प्लस मार्कर शब्द होता है जो केवल आउटपुट में दिखाई देता है यदि हमला सफल हो जाता है। छह हमलों में एक अनंत लूप, 512 MB मेमोरी ग्रैब, 200 प्रक्रियाओं का बाउंड फोर्क बाढ़, 50890008 फाइल लिखना, नकली रहस्य को पढ़ना और स्थानीय सेवा से कनेक्शन शामिल हैं। कांटा बाढ़ कैप किया गया है ताकि यह मशीन को नुकसान नहीं पहुंचा सके। अवरुद्ध हमले का मतलब है कि मार्कर वर्ड कभी भी प्रकट नहीं हुआ या अंतहीन लूप के लिए समय समाप्त हो गया।
जब उप-प्रक्रिया स्तर सामान्य Linux उपयोगकर्ता के रूप में चलता है, तो चार हमलों को अवरुद्ध कर दिया जाता है और दो गुजर जाते हैं। कांटा बाढ़ की अनुमति दी जाती है क्योंकि प्रक्रिया कैप केवल एक समर्पित उपयोगकर्ता पर लागू होती है। गुप्त फ़ाइल पठनीय है क्योंकि कोड आपके रूप में चलाता है। दोनों इस परत की वास्तविक सीमाएं हैं, और यही कारण है कि यह केवल उस कोड के लिए उपयुक्त है जिस पर आप सबसे अधिक भरोसा करते हैं।
--backend Docker और--backend e2b अगला चलाएँ. ऊपर वर्णित झंडे के साथ, Docker , सभी छह हमलों को अवरुद्ध करना चाहिए: कंटेनर में कोई नेटवर्क नहीं है, इसकी फ़ाइल सिस्टम में आपकी फाइलें शामिल नहीं हैं, और मेमोरी, प्रक्रिया और डिस्क सीमाएं लागू होती हैं। एक माइक्रोवीएम में, स्मृति, प्रक्रिया तथा डिस्क हमले आपके द्वारा चुने गए VM की सीमाओं तक चल सकते हैं, लेकिन वे इसके अंदर रहते हैं। नकली गुप्त फ़ाइल और स्थानीय सेवा वहां मौजूद नहीं हैं.
सुरक्षा समय की लागत है, इसलिए इसे मापें। बेंच स्क्रिप्ट एक वार्म-अप रन के बाद बैकएंड पर दस बार प्रिंट () चलाता है, फिर मध्य और सबसे धीमे समय को मुद्रित करता है। E2B के लिए, प्रत्येक रन माइक्रोवीएम बनाता है, ताकि मापा गया समय startup शामिल हो । सबप्रोसेस सबसे तेज़ होने की उम्मीद करें, क्योंकि यह केवल Python शुरू होता है। प्रकाशित बूट टाइम्स को दावों के रूप में मानें, गारंटी नहींः एक लेखन रिपोर्ट है कि ई 2 बी लगभग 150 एमएस में बूट्स करता है, और AWS और Docker दोनों अपने माइक्रोवीएन उत्पादों के लिए निकट-तत्काल लॉन्च का वर्णन करते हैं।
केवल उस कोड के लिए एक सीमित उप-प्रक्रिया का उपयोग करें जिस पर आप भरोसा करते हैं, जैसे कि विकास में आपकी अपनी स्क्रिप्ट। जब आप होस्ट को नियंत्रित करते हैं और दांव कम होते हैं तो कठोर कंटेनर का प्रयोग करें, और रन पैच किए गए रखें। कई उपयोगकर्ताओं से कोड के लिये माइक्रोवीएम का इस्तेमाल करें, किसी भी चीज़ के लिये जो रहस्यों को छूता है, और जब एजेंट को Python से अधिक की आवश्यकता होती है ।
आम गलतियाँ
- मॉडल को फ़ाइल एक्सेस, नेटवर्क नीति या रहस्य चुनने देना। एजेंट शुरू होने से पहले इन्फ्रास्ट्रक्चर को उन सीमाओं को परिभाषित करना चाहिए.
- उपप्रक्रिया अलगाव को अविश्वसनीय कोड के लिए पर्याप्त मानते हुए. यह आपकी फ़ाइलों और कर्नेल को साझा करता है, और परीक्षण सामान्य Linux उपयोगकर्ता के रूप में चलाए जाने पर फोर्क बाढ़ और गुप्त पढ़ने की अनुमति देता है।
- Forgetting Docker संसाधन सीमाओं के बिना, मेमोरी, मेमरी-स्वैप, सीपीयूएस, पिड्स लिमिट, नेटवर्क कोई नहीं, केवल पढ़ने योग्य, कैप ड्रॉप ऑल, नो न्यू विशेषाधिकार और यूजर, कंटेनर होस्ट प्रक्रियाओं के सेट की तरह व्यवहार कर सकता है।
- Docker के साथ कंटेनर को रोकें।
- विलंबता संख्याओं को गारंटी के रूप में पढ़ना. 150 एमएस ई 2 बी आंकड़ा और लगभग तत्काल AWS या Docker दावे प्रकाशित रिपोर्ट हैं, गारंटी नहीं; अपने मशीन पर bench.py चलाएं।

Comments (0)