kern

kern: किसी भी वर्कलोड के लिए एक तेज़, रूटलेस सैंडबॉक्स और वर्चुअल रिसोर्स रनटाइम, जिसमें अविश्वसनीय और AI-जनरेटेड कोड भी शामिल है।

एक वास्तविक, कर्नेल-प्रवर्तित कंटेनर ~3.5 ms में, बिना डेमन के एक 1.52 MB बाइनरी से।

_{आराम पर 0 RAM · कोई डेमन नहीं, कोई सॉकेट नहीं, शुरू करने के लिए कुछ नहीं · एक स्टैटिक बाइनरी, libc इसकी एकमात्र Rust निर्भरता}

# install the release binary (static, 1.52 MB, checksum-verified by the script)
curl -fsSL https://raw.githubusercontent.com/getkern/kern/main/install.sh | sh

# a throwaway shell in a real OCI image: rootless, kernel-enforced, a few ms
kern box dev --image alpine -it -- sh

_{कोई नेटिव Windows नहीं: WSL2 उपयोग करें। इंस्टॉल।}

kern क्या है

एक बाइनरी जो संसाधनों का प्रबंधन करती है, जिसमें आइसोलेशन पहला है। यही कारण है कि तुलना तालिका में kern के लिए कोई एकल पंक्ति नहीं है: यह एक साथ एक कंटेनर रनटाइम, एक सैंडबॉक्स, एक संसाधन स्लाइसर और एक स्टैक रनर है, 1.52 MB में बिना किसी डेमन के।

• एक वास्तविक कंटेनर। वास्तविक OCI इमेज: pull, Dockerfile से build, commit, push, save/load। एक इमेज से बॉक्स ~3.5 ms में शुरू होता है।
• एक सैंडबॉक्स, हमेशा रूटलेस। User, PID, mount, network, UTS और IPC नेमस्पेस, एक overlay या read-only रूट जो अंदर pivot किया गया है, एक deny-by-default seccomp allowlist और cgroup v2 सीमाएँ। एक फ़्लैग, --security-profile untrusted, पूरा हार्डन्ड बंडल है।
• संसाधन प्रोफ़ाइल, सिर्फ आइसोलेशन नहीं। CPU (vcpu:), मेमोरी, डिस्क (vdisk:) और डिवाइस (vgpio:), एक बार kern.toml में घोषित और नाम से जुड़े। kern run बिना किसी सैंडबॉक्स के, होस्ट पर एक प्रोसेस पर समान कैप लागू करता है। docs/RESOURCES.md

इसका पूरा Rust निर्भरता वृक्ष libc है: JSON और OCI मैनिफेस्ट हाथ से पार्स किए जाते हैं, और pull TLS स्टैक को लिंक करने के बजाय मशीन पर पहले से मौजूद curl और tar को शेल आउट करता है। (1.52 MB आकार-अनुकूलित रिलीज़ बिल्ड है; स्रोत से एक साधारण cargo install 1.91 MB का है।)

kern क्या नहीं है

• हाइपरवाइज़र नहीं। सीमा Linux कर्नेल है, इसलिए कर्नेल विशेषाधिकार-वृद्धि बग एक एस्केप है। Docker और Podman उसी स्थिति में हैं, यही कारण है कि gVisor और Firecracker मौजूद हैं।

  टैगलाइन के साथ पढ़ें, यह दोनों ओर से देखी गई एक पंक्ति है: अविश्वसनीय और AI-जनरेटेड कोड वही है जिसके लिए kern है, क्योंकि आपने इसे चलाना चुना और विस्फोट त्रिज्या (एजेंट टूल-कॉल, CI जॉब, बिल्ड स्टेप, कोड सेल) के मालिक हैं। यह अजनबियों के शत्रुतापूर्ण कोड, मल्टी-टेनेंट, उस कर्नेल पर जिससे आप अन्य टेनेंट्स को सेवा देते हैं, के लिए नहीं है। kern हमेशा रूटलेस शुरू होता है, जहाँ Docker में यह ऑप्ट-इन है।

• userns व्यापार से मुक्त नहीं। इसका आइसोलेशन एक विशेषाधिकार-रहित यूज़र नेमस्पेस पर बना है, जो कर्नेल LPE बग का एक उपजाऊ स्रोत है। SECURITY.md किसी भी दावे से पहले यह बताता है।

• आप जो अंदर माउंट करते हैं उसके चारों ओर दीवार नहीं। -v $HOME:/host बॉक्स को आपकी होम डायरेक्टरी देता है: एक माउंट एक विश्वास निर्णय है जो आप लेते हैं, सीमा नहीं जो kern लागू करता है। --net host और --privileged नाम से ऑप्ट-आउट हैं। (एकमात्र पथ जिसे kern बाइंड करने से मना करता है वह अपना स्वयं का रनटाइम रजिस्ट्री है।)

• Docker Engine पुनःकार्यान्वयन नहीं। यह Docker के प्रारूपों को बोलता है, उसके API को नहीं: कोई overlay नेटवर्क नहीं, कोई प्लगइन नहीं, कोई Swarm नहीं। मैट्रिक्स: docs/DOCKER-COMPAT.md।

• Kubernetes रनटाइम नहीं। कोई CRI नहीं। containerd या CRI-O उपयोग करें।

• GPU स्लाइस शिप नहीं करता। रोडमैप पर, इस संस्करण में कोई GPU कोड नहीं, इसलिए यहाँ भरोसा करने या हमला करने के लिए कुछ भी नहीं है।

यह जो नहीं जानता या अभी तक नहीं करता वह OPEN_ITEMS.md में है, न कि आपको खुद खोजने के लिए छोड़ा गया है।

इंस्टॉल

kern को विशेषाधिकार-रहित यूज़र नेमस्पेस और cgroup v2 वाले Linux कर्नेल की आवश्यकता है। यह Linux, WSL2 और ARM बोर्ड (Raspberry Pi · Jetson · Arduino UNO Q) पर चलता है; कोई नेटिव Windows बिल्ड नहीं है, WSL2 उपयोग करें (kern एक प्री-बेक्ड WSL rootfs शिप करता है)।

सबसे तेज़ तरीका रिलीज़ बाइनरी है: एक स्टैटिक फ़ाइल, कोई टूलचेन नहीं, और स्क्रिप्ट इंस्टॉल करने से पहले उसके SHA256 को सत्यापित करती है।

curl -fsSL https://raw.githubusercontent.com/getkern/kern/main/install.sh | sh

यह आपके लिए x86_64 या aarch64 चुनता है, ~/.local/bin में इंस्टॉल करता है (रूट के रूप में /usr/local/bin, या KERN_INSTALL_DIR), और ऐसे डाउनलोड को इंस्टॉल करने से मना कर देता है जिसका चेकसम मेल नहीं खाता। हाथ से सत्यापित करना दो पंक्तियों का काम है:

curl -fsSLO https://github.com/getkern/kern/releases/latest/download/kern-x86_64-unknown-linux-musl.tar.gz{,.sha256}
sha256sum -c kern-x86_64-unknown-linux-musl.tar.gz.sha256 && tar xzf kern-x86_64-unknown-linux-musl.tar.gz

स्रोत से दूसरा तरीका है, और पूरा निर्भरता वृक्ष एक क्रेट (libc) है, इसलिए यह छोटा है: क्लोन, बिल्ड और इंस्टॉल एक डेस्कटॉप (i7-14700KF) पर 36 s लगे, छोटे ARM बोर्ड पर अधिक।

# if you do not have Rust yet
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

cargo install --git https://github.com/getkern/kern getkern --locked

यह kern को ~/.cargo/bin में रखता है, जिसे rustup आपके PATH में जोड़ता है (नया शेल खोलें, या source "$HOME/.cargo/env", यदि kern नहीं मिलता है)।

रिलीज़ एक aarch64 बाइनरी, एक Windows .exe शिम और एक प्री-बेक्ड WSL rootfs भी शिप करती है, प्रत्येक का अपना .sha256 है; टैग GPG-हस्ताक्षरित और स्वतंत्र रूप से टाइमस्टैम्प्ड है (provenance/)।

kern doctor आपको बताता है कि क्या बॉक्स यहाँ चलेंगे, इससे पहले कि आप कोशिश करें। बोर्ड, WSL2 और लंबा रूप: docs/INSTALL.md। सामान्य प्रश्न (Docker, bubblewrap, youki, E2B, Windows, थ्रेट मॉडल): docs/FAQ.md।

क्विकस्टार्ट

kern box dev --image alpine -it -- sh              # a throwaway shell in a real OCI image
kern run --memory 256M --cpus 0.5 -- ./crunch      # cap a process, no sandbox
kern box svc --image nginx:alpine -d -p 8080:80 \  # a service: published, restarted, health-checked
  --restart --health-cmd 'wget -qO- localhost:80' -- nginx -g 'daemon off;'
kern ps                                            # what is running, with PORTS and HEALTH
kern exec svc -it -- sh                            # shell into it
kern stop svc                                      # its signal, its grace, then the code it exited with
kern top                                           # live TUI: boxes, CPU/RAM, profiles, volumes
kern compose stack.toml up                         # a multi-box stack (examples/) or a compose.yml
kern compose stack.toml down                       # and take it down again

अविश्वसनीय कोड, बंडल के लिए एक फ़्लैग:

kern box job --image python:3.12-slim --security-profile untrusted --memory 256m \
  -v ./job:/w -- python3 /w/x.py

--security-profile untrusted एक ऑप्ट-इन फ़्लैग में seccomp allowlist + --cap-drop ALL + --read-only है (यदि आप चाहें तो उन्हें हाथ से लिखें); मेमोरी/pids कैप वास्तव में लागू न होने पर शुरू करने से मना करने के लिए --require-limits जोड़ें। जब तक आप नहीं पूछते कोई नेटवर्क नहीं, खतरनाक क्षमताएँ हटा दी जाती हैं, seccomp हमेशा चालू। नब्बे चलाने योग्य उदाहरण, प्रत्येक एक काम करता है: examples/।

हर read वर्ब JSON में भी उत्तर देता है, इसलिए किसी को तालिका पार्स नहीं करनी पड़ती:

kern ps --json | jq '.[] | select(.health == "unhealthy") | .name'
kern volume ls --json          # ps · images · stats · inspect · builds · pod ls · config list · diff

आपका Docker Compose स्टैक, Docker Desktop के बिना

kern docker-compose.yml बोलता है। इसे अपने पहले से मौजूद स्टैक पर इंगित करें और kern compose up इसे बिना डेमन और बिना Docker Desktop के चलाता है, Linux, WSL2 और ARM बोर्ड पर समान।

# compose.yaml - a real stack, unchanged
services:
  db:
    image: postgres:alpine
    environment: { POSTGRES_PASSWORD: secret, POSTGRES_DB: app }
  web:
    image: adminer
    ports: ["8080:8080"]
    depends_on: [db]

kern compose compose.yaml up

दोनों आधिकारिक इमेज शुरू होती हैं, web सेवा नाम से db तक पहुँचता है, और पोर्ट होस्ट पर प्रकाशित होता है। वार्म (इमेज कैश्ड) वेब टियर ~0.3 s में सेवा देता है, और स्टैक की लागत केवल वही है जो postgres और adminer वास्तव में उपयोग करते हैं (~66 MB यहाँ), शीर्ष पर शून्य डेमन के साथ, जहाँ Docker Desktop आपके पहले कंटेनर से पहले एक बैकग्राउंड VM है।

आधिकारिक इमेज जो गैर-रूट उपयोगकर्ता पर गिरती हैं (postgres, redis, ...) uidmap और /etc/subuid पंक्ति चाहती हैं, और आउटबाउंड इमेज पुल pasta चाहते हैं; दोनों एक डेव बॉक्स पर एक apt install हैं, और kern doctor किसी भी लापता को नाम देता है। यह स्थानीय डेव लूप है, प्रोडक्शन ऑर्केस्ट्रेटर नहीं: कोई Swarm नहीं, कोई overlay नेटवर्क नहीं।

इसे एम्बेड करें: Python और Node

अपने स्वयं के प्रोग्राम से एजेंट या LLM-जनरेटेड कोड चलाएँ kern-sandbox, kern बाइनरी के ऊपर एक पतला, निर्भरता-मुक्त रैपर। हर कॉल एक नए आइसोलेटेड बॉक्स में चलती है: नेटवर्क बंद, मेमोरी और pid कैप, क्षमताएँ हटाई गईं, आउटपुट सीमित, और एक टाइमआउट जिसे बाइंडिंग स्वयं लागू करती है।

pip install kern-sandbox        # PyPI   · needs the `kern` binary above, on PATH or $KERN_BIN
npm  install kern-sandbox       # npm    · same

from kern_sandbox import run_code

r = run_code("import platform; print(platform.python_version())")
print(r.stdout)          # ran in a fresh box; a timeout / OOM / blocked escape is data on r.fault

• फॉल्ट डेटा हैं, अपवाद नहीं: एक टाइमआउट, OOM-किल या अवरुद्ध syscall परिणाम पर एक फ़ील्ड है, raise नहीं। डिफ़ॉल्ट रूप से प्रति कॉल एक नया बॉक्स; Sandbox कॉल के बीच एक वर्कस्पेस रखता है और एक वार्म kernel() सब-मिलीसेकंड सेल के लिए एक इंटरप्रेटर रखता है (कमज़ोर आइसोलेशन, पसंद से)।
• Jupyter कर्नेल के बिना समृद्ध परिणाम: अंतिम एक्सप्रेशन, display() और matplotlib आकृतियाँ कैप्चर करके लौटती हैं, नोटबुक सेल की तरह।
• एक MCP सर्वर (kern-mcp) शिप करता है: एक निर्भरता-मुक्त stdio सर्वर जो Claude Desktop, Cursor या किसी भी MCP क्लाइंट को एक स्थानीय कोड इंटरप्रेटर देता है। क्लाइंट को इस पर इंगित करें:

{ "mcpServers": { "kern": { "command": "kern-mcp" } } }

टूल: run_code (python/bash/node), write_file, read_file, list_files। हर कॉल एक नया नेटवर्क-बंद बॉक्स है; फ़ाइलें कॉल के बीच डिस्क पर एक वर्कस्पेस में बनी रहती हैं। सेटअप कमांड, इमेज और अन्य विकल्प: bindings/python/README.md।

पूरा API, Python और Node: bindings/python/README.md · bindings/node/README.md।

संसाधन प्रोफ़ाइल

एक स्लाइस एक बार ~/.config/kern/kern.toml में घोषित किया जाता है और नाम से जुड़ा होता है, एक सैंडबॉक्स्ड बॉक्स या बेयर प्रोसेस से, उसी टोकन के साथ।

तीन प्रकार: vcpu: (CPU और मेमोरी), vdisk: (आकार-सीमित स्क्रैच डिस्क) और vgpio: (डिवाइस नोड)। उनमें से दो, और वे एंकर जिनसे वे काटे गए हैं:

[[cpu]]                     # the host budget a slice is carved from
id    = "cpu:0"
cores = 8.0

[[vcpu]]                    # 1.5 cores and 512 MiB  ->  attach as  vcpu:heavy
name    = "heavy"
backend = "cpu:0"
cpus    = 1.5
memory  = "512m"

[[gpio]]                    # a controller anchor
id = "gpio:0"

[[vgpio]]                   # exactly one device node ->  attach as  vgpio:sensor
name    = "sensor"
backend = "gpio:0"
i2c     = ["/dev/i2c-1"]

kern validate ~/.config/kern/kern.toml       # check it before anything runs
kern box train --image alpine vcpu:heavy vdisk:scratch -- ./train.sh
kern run vcpu:heavy -- ./train.sh            # the same slice, no sandbox
kern box iot --image alpine vgpio:sensor -- ls /dev

प्रोफ़ाइल संयोजित होती हैं: कई एक बॉक्स से जुड़ती हैं, और एक स्पष्ट फ़्लैग प्रोफ़ाइल के अपने मान को हरा देता है। हर कुंजी अपने CLI फ़्लैग की तरह लिखी जाती है, इसलिए cpus --cpus है और memory --memory है। एक बैकएंड जो किसी घोषित पूल का नाम नहीं देता, कॉन्फ़िग पढ़ते समय अस्वीकार कर दिया जाता है, बॉक्स चलने पर नहीं। docs/RESOURCES.md में फ़ील्ड-दर-फ़ील्ड स्कीमा है।

एक vdisk: जब kern रूटलेस चलता है तो RAM-बैक्ड tmpfs होता है, चाहे उसका बैकएंड कुछ भी कहे, और जब यह विशेषाधिकारित चलता है तो वास्तविक कोटा के साथ एक ext4-on-loop इमेज। kern बताता है कि आपको कौन सा मिला, प्रति प्रोफ़ाइल, आपको अनुमान लगाने देने के बजाय, और आकार सीमा दोनों तरह से लागू होती है।

vgpio: चिप-ग्रैन्युलर है, प्रति-लाइन नहीं। pins माँगना पूरे /dev/gpiochipN को बाँधता है, और वह कैरेक्टर डिवाइस उस कंट्रोलर की हर लाइन को उजागर करता है। pins = [17] बॉक्स को लाइन 17 तक प्रतिबंधित नहीं करता: कर्नेल के पास कोई प्रति-लाइन माउंट सीमा नहीं है, इसलिए पिन सूची एक सहयोगी मेटाडेटा है, सीमा नहीं। एक डिवाइस नोड का नाम देना, जैसा i2c ऊपर करता है, उस नोड को प्रदान करता है और कुछ और नहीं।

kern बनाम Docker बनाम Podman

प्रदर्शन

Intel i7-14700KF, Linux 7.0.0, रिलीज़ बाइनरी, एक स्क्रिप्ट जिसे आप स्वयं चला सकते हैं: python3 examples/benchmark.py। आपके परिणाम आपके CPU, कर्नेल और फाइलसिस्टम के साथ भिन्न होंगे।

एक साथ तीन हज़ार ~2.2 s लेते हैं, और एक लाइव बॉक्स की लागत ~0.3 MB मेमोरी है।

दो ईमानदार नोट। कोई भी सिंगल-शॉट लेटेंसी में पूरी तरह नहीं जीतता: unshare + exec के लिए न्यूनतम सीमा 1 से 2 ms है, इसलिए पूरा शीर्ष स्तर अपने स्वयं के शोर के भीतर बैठता है, और bubblewrap एक लॉन्चर है जिसमें कोई इमेज, कैप या लाइफसाइकिल नहीं है। जो अंतर मायने रखता है वह इंजनों के लिए है, दो ऑर्डर ऑफ मैग्नीट्यूड ऊपर।

विधि, प्रति-चरण विवरण, बोर्ड संख्याएँ और हर चेतावनी: BENCHMARKS.md।

सुरक्षा

नेमस्पेस, एक pivot_root, exec से पहले 16 खतरनाक क्षमताएँ हटाई गईं, डिफ़ॉल्ट रूप से एक हमेशा-ऑन seccomp allowlist (moby का अपना डिफ़ॉल्ट फ़िल्टर माइनस kern के 35 एस्केप syscalls, जो हार्ड-किल रहते हैं; वैटेड सेट के बाहर का syscall ENOSYS लौटाता है, और व्यापक denylist KERN_SECCOMP=denylist के माध्यम से ऑप्ट-आउट है), cgroup v2 सीमाएँ (--require-limits शुरू करने से मना कर देता है जब तक कि वे बाइंड न हों), और एक deny-by-default /dev। जहाँ एक सीमा सहयोगी है, कर्नेल-प्रवर्तित नहीं, SECURITY.md ऐसा कहता है और बाइपास का नाम देता है।

आपको इसे विश्वास पर लेने की ज़रूरत नहीं है: pentest/ में चार प्रतिकूल सूट हैं जो उन सीमाओं को kern की अपनी रिपोर्टिंग के बजाय कर्नेल के विरुद्ध परखते हैं, और वे बिना रजिस्ट्री खाते या नेटवर्क के चलते हैं।

sh pentest/run-with-local-registry.sh ./target/release/kern pentest/pentest-ports.sh

GitHub Security Advisories या [email protected] के माध्यम से निजी तौर पर भेद्यता की रिपोर्ट करें।

दस्तावेज़ीकरण

स्थिति

कोर पूरा हो चुका है। ऊपर सब कुछ आज काम करता है: 840 Rust, 78 Python और 61 Node परीक्षण, clippy-क्लीन, cargo-deny-क्लीन, वास्तविक हार्डवेयर पर: Linux, WSL2, Raspberry Pi 5, Jetson Orin Nano, Arduino UNO Q। v0.7.0 पहला प्रकाशित रिलीज़ है। CLI और कॉन्फ़िग सतह अभी भी बदल सकती है, हमेशा CHANGELOG.md में सूचित किया जाता है।

योगदान

इश्यू और पुल रिक्वेस्ट का स्वागत है। CONTRIBUTING.md में वर्कफ़्लो और गेट्स हैं; योगदान CLA द्वारा कवर किए गए हैं।

अनुरक्षक

Alex, @realexhub। कमिट @getkerndev से आते हैं, परियोजना की कमिट पहचान।

कमिट हस्ताक्षरित नहीं हैं; रिलीज़ TAG है। यही सत्यापित करना है: git verify-tag v0.7.0 provenance/ में कुंजी के विरुद्ध, जिसका फिंगरप्रिंट SECURITY.md में है।

लाइसेंस

Apache-2.0। देखें LICENSE और TRADEMARK.md।