VPSలో sandboxdని సొంతంగా హోస్ట్ చేయడం ఎలా?

sandboxd అంటే ఏమిటి మరియు దానిని మీరే సొంతంగా రన్ చేయడం వల్ల కలిగే ప్రయోజనాలు

sandboxd ను self-host చేయడానికి మీకు Docker ఉన్న ఒక Linux సర్వర్ మరియు ఒక domain name అవసరం. మీరు ఒక prompt పంపినప్పుడు, ఒక coding agent ఐసోలేటెడ్ కంటైనర్ లోపల ఒక నిజమైన అప్లికేషన్‌ను నిర్మిస్తుంది, ఆ అప్లికేషన్ దాని స్వంత preview URL వద్ద అందుబాటులోకి వస్తుంది. 2026లో Prompt-to-app బిల్డర్లు అత్యంత ప్రాచుర్యం పొందిన hosted కేటగిరీగా ఉన్నాయి, మరియు sandboxd అనేది మీ VPSపై, MIT లైసెన్స్ కింద రన్ అయ్యే సాఫ్ట్‌వేర్; దీని ద్వారా తయారైన కోడ్ మీ స్వంత డిస్క్‌లోనే ఉంటుంది.

దీని డిజైన్ ఉద్దేశపూర్వకంగానే చిన్నదిగా ఉంచబడింది. ఒక Go control plane Docker ను నడిపిస్తుంది, Traefik v3 ప్రతి preview hostname ను రూట్ చేస్తుంది, SQLite స్టేట్‌ను భద్రపరుస్తుంది, మరియు ప్రతి అప్లికేషన్ ఒక కంటైనర్ లోపల రన్ అవుతుంది. ఇందులో Kubernetes లేదు మరియు ప్రత్యేకమైన database సర్వర్ కూడా లేదు, అందుకే ఇది 2 vCPU ఉన్న సర్వర్‌పై కూడా రన్ అవ్వగలదు.

నాలుగు ఆబ్జెక్టులు మొత్తం మోడల్‌ను నడిపిస్తాయి. ఒక app అనేది శాశ్వత ప్రాజెక్ట్, ఇది దాని పేరు, git మెటాడేటా మరియు secrets ను కలిగి ఉంటుంది. ఒక sandbox అనేది అప్లికేషన్ రన్ అయ్యే Docker కంటైనర్, మరియు ఒక app ఒక సమయంలో ఒక sandbox కు మాత్రమే అనుసంధానించబడి ఉంటుంది. ఒక workspace అనేది అప్లికేషన్ యొక్క ఫైళ్లు, ఇవి హోస్ట్ మెషీన్‌పై ఉంటాయి మరియు కంటైనర్ ఆగిపోయినా అలాగే ఉంటాయి. ఒక task అనేది sandbox లోపల ఉన్న agent కు పంపబడే ఒక prompt. ఒక sandbox ను ఆపడం వల్ల మెమరీ ఖాళీ అవుతుంది కానీ ఫైళ్లు అలాగే ఉంటాయి. దానిని destroy చేయడం వల్ల కంటైనర్ తొలగించబడుతుంది, ఆ తర్వాత app కొత్త దానిని boot చేయగలదు.

sandboxd, Dify మరియు OpenHands ల మధ్య తేడాలు ఏమిటి?

ఈ మూడూ మీ సర్వర్‌పై LLM (large language model) ను రన్ చేస్తాయి కాబట్టి వీటి మధ్య గందరగోళం ఏర్పడుతుంది, కానీ వీటి ద్వారా వచ్చే ఫలితాలు వేరుగా ఉంటాయి. Dify LLM అప్లికేషన్లను నిర్మిస్తుంది: ఎవరైనా ఉపయోగించిన ప్రతిసారీ మోడల్‌ను పిలిచే చాట్ ఇంటర్‌ఫేస్‌లు, రిట్రీవల్ పైప్‌లైన్‌లు మరియు వర్క్‌ఫ్లోలను ఇది రూపొందిస్తుంది. మోడల్ అనేది తయారైన ఉత్పత్తిలో ఒక భాగంగా ఉంటుంది. OpenHands ఇప్పటికే ఉన్న రిపోజిటరీపై పనిచేస్తుంది: మీరు దీన్ని మీ కోడ్‌కు పాయింట్ చేసినప్పుడు, అది ఫైళ్లను చదువుతుంది, కమాండ్లను రన్ చేస్తుంది మరియు మార్పులను సూచిస్తుంది. sandboxd సున్నా నుండి మొదలవుతుంది. ఇది ఒక preset నుండి ప్రాజెక్ట్‌ను సిద్ధం చేసి, కొత్త కంటైనర్‌లో బిల్డ్ చేసి, మీరు చూడటానికి ఒక URLను ఇస్తుంది. దీని ద్వారా వచ్చేది సాధారణ React లేదా FastAPI అప్లికేషన్, ఇది రన్ అవ్వడానికి ఎటువంటి మోడల్ అవసరం లేదు.

కాబట్టి చివరగా మీకు ఏమి కావాలో దానిని బట్టి ఎంచుకోండి. ఒక వాక్యం నుండి ప్రారంభించి, ఆ తర్వాత కోడ్‌ను ఉంచుకోవడానికి sandboxd ఉపయోగపడుతుంది. మిగిలిన రెండూ ఇప్పటికే రిపోజిటరీ లేదా మోడల్-ఆధారిత ఉత్పత్తి ఉన్నప్పుడు ఉపయోగపడతాయి.

మరొక తేడా వాటి వయస్సు, దీనిపై మీరు ఏదైనా ముఖ్యమైనది నిర్మించే ముందు పరిగణనలోకి తీసుకోవాలి.

[
  {
    "tool": "sandboxd",
    "github_stars": "875",
    "forks": "50"
  },
  {
    "tool": "OpenHands",
    "github_stars": "83,091",
    "forks": "10,711"
  },
  {
    "tool": "Dify",
    "github_stars": "151,320",
    "forks": "23,886"
  }
]

sandboxd 875 స్టార్లను కలిగి ఉండగా, OpenHands 83,091 మరియు Dify 151,320 స్టార్లను కలిగి ఉన్నాయి. ఈ రిపోజిటరీ 3 జూన్ 2026న సృష్టించబడింది, కాబట్టి ఆగస్టు 2026 నాటికి దీనికి రెండు నెలల వయస్సు ఉంది. అదే సమయంలో OpenHands మార్చి 2024 నుండి, Dify ఏప్రిల్ 2023 నుండి అందుబాటులో ఉన్నాయి. v0.1.0 రిలీజ్ 6 జూన్ 2026న మరియు v0.3.6 రిలీజ్ 1 ఆగస్టు 2026న విడుదలయ్యాయి. ఈ ప్రాజెక్ట్ తనను తాను బీటా అని పిలుచుకుంటుంది మరియు 0.x రిలీజ్‌లు అనుకూలతను దెబ్బతీసే అవకాశం ఉందని పేర్కొంది. ఈ సంఖ్యలను నాణ్యతకు కొలమానంగా కాకుండా, డిపెండెన్సీ రిస్క్‌గా పరిగణించండి: రెండు నెలల వయస్సు ఉన్న ప్రాజెక్ట్‌లో ఇతరులు బగ్‌లను కనుగొనడానికి కేవలం రెండు నెలల సమయం మాత్రమే లభించింది.

సర్వర్‌కు అవసరమైనవి మరియు వనరుల కొరత ఏర్పడినప్పుడు కలిగే సమస్యలు

ఈ ప్రాజెక్ట్ ప్రారంభించడానికి 2 vCPU మరియు 4 GB RAM సరిపోతాయని పేర్కొంది. కంట్రోల్ ప్లేన్ మరియు ఒక చిన్న శాండ్‌బాక్స్ కోసం ఇది సరిగ్గా సరిపోతుంది, కానీ ఇద్దరు వ్యక్తులు ఒకే సమయంలో పని చేస్తుంటే ఇది సరిపోదు. మెమరీని విభజించి కేటాయించండి. Traefik మరియు Go కంట్రోల్ ప్లేన్ చాలా తక్కువ మెమరీని తీసుకుంటాయి. ప్రతి రన్నింగ్ శాండ్‌బాక్స్ ఒక పూర్తి Node లేదా Python టూల్‌చైన్‌ను కలిగి ఉంటుంది, మరియు పీక్ సమయంలో npm install ఆపై ప్రొడక్షన్ బిల్డ్ జరుగుతుంది. కొన్ని అప్లికేషన్లను రన్ చేసే సర్వర్ కోసం 8 GB మెమరీని ప్లాన్ చేయండి. swap ను అదనపు సామర్థ్యంగా కాకుండా, కేవలం రక్షణగా మాత్రమే చూడండి, ఎందుకంటే swap మెమరీని ఉపయోగించే బిల్డ్ సెకన్లలో కాకుండా నిమిషాల సమయం తీసుకుంటుంది.

మెమరీ అయిపోయినప్పుడు రెండు రకాల వైఫల్యాలు సంభవిస్తాయి, ఇవి రెండూ భిన్నంగా ఉంటాయి. శాండ్‌బాక్స్ లోపల, కంటైనర్ sandboxd సెట్ చేసిన గరిష్ట --memory పరిమితిని చేరుకుంటుంది. అప్పుడు కెర్నల్ అతిపెద్ద ప్రాసెస్‌ను నిలిపివేస్తుంది (kill), కాబట్టి ఏజెంట్ నుండి ఎటువంటి ఉపయోగకరమైన సందేశం లేకుండానే బిల్డ్ ఆగిపోతుంది. docker ps -a ఆ కంటైనర్ కోసం exit code 137 ను చూపిస్తుంది మరియు దానిపై docker inspect రన్ చేస్తే "OOMKilled": true అని వస్తుంది. ఈ విధంగా ఆగిపోయే Node బిల్డ్ తరచుగా మొదట JavaScript heap out of memory అని ప్రింట్ చేస్తుంది.

రెండవ వైఫల్యం హోస్ట్ సర్వర్‌పై జరుగుతుంది. హోస్ట్ మెమరీ తక్కువగా ఉన్నప్పుడు శాండ్‌బాక్స్‌లను ఆపడానికి sandboxd ఒక ప్రెజర్ రీపర్‌ను రన్ చేస్తుంది. కాబట్టి చిన్న సర్వర్లలో, మీరు ప్రివ్యూ చూస్తున్నప్పుడే శాండ్‌బాక్స్ అదృశ్యం కావచ్చు. ఫైళ్లు సురక్షితంగానే ఉంటాయి మరియు ప్రివ్యూ URL ను మళ్ళీ రిక్వెస్ట్ చేసినప్పుడు అది తిరిగి ప్రారంభమవుతుంది, కానీ కంటైనర్ ఆగిపోయినప్పుడు రన్ అవుతున్న టాస్క్ మాత్రం కొనసాగదు.

డిస్క్ స్పేస్ అనేది అంతగా బయటపడని సమస్య. ప్రతి అప్లికేషన్ హోస్ట్‌పై తన సొంత వర్క్‌స్పేస్‌ను కలిగి ఉంటుంది, మరియు ఒక JavaScript ప్రాజెక్ట్ వందల మెగాబైట్ల node_modules ట్రీని కలిగి ఉంటుంది. పది అప్లికేషన్లు అంటే ఇమేజ్‌లను లెక్కించకముందే కొన్ని గిగాబైట్ల డిపెండెన్సీలు ఉంటాయి. 40 GB తో ప్రారంభించి, దానిని గమనిస్తూ ఉండండి:

docker system df
sudo du -sh /var/lib/sandboxed/workspaces

డిఫాల్ట్ డేటా డైరెక్టరీ /var/lib/sandboxed, ఇందులో అదనంగా e ఉంటుంది. పొరపాటున /var/lib/sandboxd అని టైప్ చేస్తే, మీకు ఖాళీ డైరెక్టరీ కనిపిస్తుంది మరియు ఐదు నిమిషాల పాటు అయోమయానికి గురవుతారు.

pinned sandboxd release ను ఇన్‌స్టాల్ చేయడం

Docker Engine తో పాటు Compose plugin మరియు git ముందుగా సర్వర్‌లో ఉండాలి. VPS పై Docker ను ఇన్‌స్టాల్ చేయడం అనే విభాగం దీనిని వివరిస్తుంది.

docker compose version
git --version

ఈ రెండూ వెర్షన్ వివరాలను చూపాలి. docker: 'compose' is not a docker command అని వస్తే, మీ దగ్గర పాత standalone docker-compose బైనరీ ఉందని అర్థం; కానీ ఇన్‌స్టాలర్ v2 ప్లగిన్‌ను ఆశిస్తుంది.

ఇన్‌స్టాలర్ అనేది నెట్‌వర్క్ ద్వారా డౌన్‌లోడ్ అయ్యే షెల్ స్క్రిప్ట్, కాబట్టి దానిని రన్ చేసే ముందు చదవండి మరియు వెర్షన్‌ను పిన్ (pin) చేయండి.

curl -fsSL https://raw.githubusercontent.com/tastyeffectco/sandboxd/v0.3.6/install.sh -o install-sandboxd.sh
less install-sandboxd.sh
SANDBOXD_REF=v0.3.6 bash install-sandboxd.sh

SANDBOXD_REF అనేది ఇన్‌స్టాలర్ $HOME/.sandboxd/src లోకి చెక్-అవుట్ చేసే git ref, ఇది డిఫాల్ట్‌గా main కి సెట్ చేయబడి ఉంటుంది. దీనిని సెట్ చేయకుండా వదిలేస్తే, ఆ రోజు ఉదయానికి మెర్జ్ అయిన కోడ్ ఇన్‌స్టాల్ అవుతుంది. జూలై 2026లోనే ఆరు రిలీజ్‌లు విడుదల చేసిన ప్రాజెక్ట్ విషయంలో ఇది ముఖ్యం. కాబట్టి వెర్షన్‌ను పిన్ చేయండి, ఆపై changelog చదివిన తర్వాతే ఉద్దేశపూర్వకంగా అప్‌గ్రేడ్ చేయండి.

ఈ స్క్రిప్ట్ సోర్స్ కోడ్‌ను క్లోన్ చేసి, ఇమేజ్‌లను బిల్డ్ చేసి, docker compose up -d తో స్టాక్‌ను ప్రారంభిస్తుంది. చివరగా కన్సోల్ URL మరియు API టోకెన్‌ను చూపిస్తుంది. ఆ టోకెన్‌ను సురక్షితంగా దాచుకోండి. ఇది root యూజర్‌గా Docker ను నియంత్రించే API కి సంబంధించిన క్రెడెన్షియల్.

curl http://127.0.0.1:9090/healthz

కంట్రోల్ ప్లేన్ సిద్ధంగా ఉన్నప్పుడు ఇది ok అని ప్రింట్ చేస్తుంది. ఒకవేళ ఏమీ ప్రింట్ అవ్వకపోతే, స్టాక్ ప్రారంభం కాలేదని అర్థం: ఏ సర్వీస్ ఆగిపోయిందో చూడటానికి ~/.sandboxd/src డైరెక్టరీ నుండి docker compose ps రన్ చేయండి, ఆపై కారణం తెలుసుకోవడానికి docker compose logs sandboxd ఉపయోగించండి.

రిమోట్ సర్వర్‌లోని కన్సోల్‌ను చేరుకోవడం

కన్సోల్ Traefik ద్వారా HTTP_PORT పోర్ట్‌లో అందుబాటులో ఉంటుంది, ఇది డిఫాల్ట్‌గా 80వ పోర్ట్, మరియు దీని hostname http://console.localhost. Traefik హోస్ట్‌నేమ్ ఆధారంగా రూటింగ్ చేస్తుంది, కాబట్టి మీ సర్వర్ IP అడ్రస్‌ను బ్రౌజర్‌లో ఎంటర్ చేస్తే ఏ నియమం సరిపోలదు మరియు 404 ఎర్రర్ వస్తుంది. మీరు సరైన డొమైన్‌ను సెట్ చేసే వరకు, పోర్ట్‌ను ఫార్వర్డ్ చేసి హోస్ట్‌నేమ్‌ను అలాగే ఉంచండి:

ssh -L 8080:127.0.0.1:80 you@your-vps

ఆ తర్వాత మీ ల్యాప్‌టాప్‌లో http://console.localhost:8080 ని ఓపెన్ చేయండి. Linux మరియు macOS లలో .localhost తో ముగిసే ఏదైనా పేరు 127.0.0.1 కి రిజాల్వ్ అవుతుంది, కాబట్టి అభ్యర్థన సరైన Host హెడర్‌తో టన్నెల్ ద్వారా వెళ్తుంది. మొదటిసారి సందర్శించినప్పుడు కన్సోల్ పాస్‌వర్డ్‌ను సెట్ చేయండి.

ఏజెంట్‌కు ఒక మోడల్‌ను కేటాయించడం

బేస్ ఇమేజ్‌లో OpenCode మరియు Claude Code అనే రెండు కోడింగ్ ఏజెంట్లు అందుబాటులో ఉంటాయి. ఏజెంట్ పేరును పేర్కొనని టాస్క్‌లను ఏది రన్ చేయాలో SANDBOXD_DEFAULT_AGENT నిర్ణయిస్తుంది, ఇది డిఫాల్ట్‌గా opencodeని ఎంచుకుంటుంది. ఎటువంటి కీ (key) కనెక్ట్ చేయనప్పుడు, టాస్క్‌లు OpenCode Zen యొక్క కీ-రహిత ఉచిత మోడళ్లపై రన్ అవుతాయి. కాబట్టి మీ మొదటి బిల్డ్ ఉచితంగా పూర్తవుతుంది మరియు మీరు ఎటువంటి ఖర్చు లేకుండా మొత్తం లూప్‌ను పరీక్షించుకోవచ్చు.

మీకు మరింత శక్తివంతమైన మోడల్ కావాలనుకున్నప్పుడు మీ స్వంత కీని కనెక్ట్ చేయండి. కీలు కంట్రోల్ ప్లేన్‌కు మాత్రమే వెళ్తాయి, శాండ్‌బాక్స్‌లోకి ఎప్పటికీ వెళ్లవు: అవి డేటా డైరెక్టరీలో ఎన్‌క్రిప్ట్ చేయబడి భద్రపరచబడతాయి మరియు క్రెడెన్షియల్ ప్రాక్సీ ద్వారా నెట్‌వర్క్ వైర్ ద్వారా పంపబడతాయి. కాబట్టి ఏజెంట్ గానీ, అది రాసే కోడ్ గానీ వాటిని చదవలేవు.

export API=http://127.0.0.1:9090
export SANDBOXD_TOKEN=sk_...                       # printed by the installer
export AUTH="Authorization: Bearer $SANDBOXD_TOKEN"

curl -s -XPOST $API/v1/agents/claude-code/api-key -H "$AUTH" \
  -H 'content-type: application/json' \
  -d '{"api_key":"sk-ant-..."}'

కన్సోల్‌లో Settings, AI Agents విభాగంలో కూడా ఇదే ప్రక్రియ ఉంటుంది. మీరు API కీకి బదులుగా Claude సబ్‌స్క్రిప్షన్‌ను ఉపయోగించాలనుకుంటే, ఇందులో గైడెడ్ OAuth ఫ్లో కూడా అందుబాటులో ఉంటుంది. ప్రతి ఏజెంట్‌కు సంబంధించిన డిఫాల్ట్ మోడల్ అదే ప్యానెల్‌లో ఉంటుంది, అయితే ఒకే టాస్క్ కోసం దానిని మార్చుకోవచ్చు (override చేయవచ్చు).

ఒక చిన్న అప్లికేషన్‌ను పూర్తిగా నిర్మించండి

అప్లికేషన్‌ను సృష్టించి, దాని sandbox ను బూట్ చేయండి, ఆపై ఒక ప్రాంప్ట్‌ను పంపండి. ఐడిలు (ids) JSON రూపంలో తిరిగి వస్తాయి, మరియు క్విక్‌స్టార్ట్ వాటిని sed తో సంగ్రహిస్తుంది, కాబట్టి మీకు jq ఇన్‌స్టాల్ చేయాల్సిన అవసరం లేదు.

APP=$(curl -s -XPOST $API/v1/apps -H "$AUTH" \
  -H 'content-type: application/json' \
  -d '{"name":"todo","runtime_preset":"react-vite"}' \
  | sed -E 's/.*"id":"([^"]+)".*/\1/')

SB=$(curl -s -XPOST $API/v1/apps/$APP/sandbox -H "$AUTH" \
  -H 'content-type: application/json' -d '{"ports":[3000]}' \
  | sed -E 's/.*"id":"([^"]+)".*/\1/')

echo "app=$APP sandbox=$SB"

రెండు వేరియబుల్స్ తప్పనిసరిగా ఒక ఐడిని కలిగి ఉండాలి. $SB ఖాళీగా ఉందంటే sandbox బూట్ కాలేదని అర్థం; సాధారణంగా బేస్ ఇమేజ్ ఇంకా బిల్డ్ అవుతుండటం లేదా హోస్ట్ మెమరీ అయిపోవడం దీనికి కారణం. ఐడికి బదులుగా 401 కనిపిస్తే, బేరర్ టోకెన్ (bearer token) తప్పుగా ఉందని అర్థం.

curl -s -XPOST $API/v1/sandboxes/$SB/tasks -H "$AUTH" \
  -H 'content-type: application/json' \
  -d '{"prompt":"Add a todo list with a text input, an add button, and a delete button on each row. Keep the list in localStorage.","agent":"opencode"}'

ప్రతిస్పందన ఒక టాస్క్ ఐడిని కలిగి ఉంటుంది. GET /v1/sandboxes/$SB/tasks/<task id> దాని ఫలితాన్ని తిరిగి ఇస్తుంది, మరియు అదే టాస్క్‌పై ఉన్న /events పాత్ ఏజెంట్ ఏమి చేస్తుందో తెలిపే లైవ్ SSE (server sent events) స్ట్రీమ్. కన్సోల్ అదే స్ట్రీమ్‌ను చాట్ రూపంలో చూపిస్తుంది.

అప్లికేషన్ అప్పుడు http://s-<sandbox id>-3000.preview.localhost వద్ద ఉంటుంది, ఇక్కడ 3000 అనేది మీరు కోరిన పోర్ట్. ఒకవేళ sandbox నిద్రపోతుంటే (asleep), మొదటి అభ్యర్థన Traefik యొక్క catch-all కు చేరుతుంది, sandboxd కంటైనర్‌ను ప్రారంభిస్తుంది, పోర్ట్ స్పందించే వరకు వేచి ఉంటుంది, మరియు మీ అప్లికేషన్‌కు రీఫ్రెష్ అయ్యే ఒక చిన్న వార్మింగ్ పేజీని చూపిస్తుంది. ప్రివ్యూ ఆ పేజీని దాటి ముందుకు వెళ్లడం లేదంటే, అప్లికేషన్ యొక్క sandbox.yaml లో ప్రకటించిన పోర్ట్‌పై లోపల ఉన్న ప్రాసెస్ వినడం లేదని (listening) అర్థం.

ప్రివ్యూలను HTTPSతో కూడిన నిజమైన డొమైన్‌పై ఉంచడం

ప్రతి శాండ్‌బాక్స్‌కు దాని స్వంత హోస్ట్‌నేమ్ ఉంటుంది, కాబట్టి ఒకే వైల్డ్‌కార్డ్ DNS రికార్డ్ వాటన్నింటినీ కవర్ చేస్తుంది. *.preview.yourdomain.comని సర్వర్ యొక్క IP అడ్రస్‌కు A రికార్డుతో పాయింట్ చేయండి. ఆపై ~/.sandboxd/srcలోని .envలో ప్రివ్యూ వేరియబుల్స్‌ను సెట్ చేయండి:

PREVIEW_DOMAIN=yourdomain.com
PREVIEW_ENTRYPOINT=websecure
PREVIEW_TLS=true
SANDBOXD_API_AUTH_DISABLED=false

Traefik కు దీనికి సరిపోయే మరొక భాగం అవసరం: traefik/traefik.ymlలో websecure ఎంట్రీ పాయింట్‌ను ఎనేబుల్ చేయండి మరియు సర్టిఫికేట్ రిజాల్వర్‌ను జోడించండి. DNS-01 ఛాలెంజ్‌ను ఉపయోగించండి, ఎందుకంటే ఒకే వైల్డ్‌కార్డ్ సర్టిఫికేట్ ప్రతి ప్రివ్యూ హోస్ట్‌నేమ్‌ను కవర్ చేస్తుంది. HTTP-01తో అయితే ప్రతి కొత్త శాండ్‌బాక్స్‌కు విడిగా జారీ చేయాల్సి ఉంటుంది, దీనివల్ల బిజీగా ఉన్న సమయంలో Let's Encrypt రేట్ పరిమితులను ఎదుర్కోవాల్సి వస్తుంది. DNS-01 ఛాలెంజ్ ద్వారా వైల్డ్‌కార్డ్ సర్టిఫికేట్లు దీనికి సంబంధించిన DNS అంశాలను వివరిస్తుంది.

cd ~/.sandboxd/src
docker compose up -d

ప్రివ్యూ URLలు https://s-<id>-3000.preview.yourdomain.comగా మారుతాయి. ఫైర్‌వాల్‌లో 80 మరియు 443 పోర్ట్‌లను ఓపెన్ చేయండి మరియు 9090ని బయటి ప్రపంచానికి క్లోజ్ చేయండి: ప్రాథమిక ufw ఫైర్‌వాల్ నియమాలు చూడండి. ప్రివ్యూ హోస్ట్‌నేమ్‌ను ఊహించగలిగే ఎవరైనా యాప్‌ను లోడ్ చేయగలరని గుర్తుంచుకోండి, కాబట్టి ప్రివ్యూలను పబ్లిక్‌గా పరిగణించండి.

ఉత్పత్తి అయిన కోడ్ ఎక్కడ నిల్వ చేయబడుతుంది మరియు దానిని ఎగుమతి (export) చేయవచ్చా?

హోస్ట్ మెషీన్‌లో, డేటా డైరెక్టరీ కింద ఇది ఉంటుంది. ప్రతి వర్క్‌స్పేస్ /var/lib/sandboxed/workspaces/<id>/ వద్ద ఒక సాధారణ డైరెక్టరీగా ఉంటుంది, ఇది కంటైనర్‌లోకి bind mount చేయబడుతుంది మరియు అప్లికేషన్ ఫైళ్లు శాండ్‌బాక్స్ లోపల /home/sandbox/workspace/app వద్ద ఉంటాయి. కంట్రోల్ ప్లేన్ స్థితి state/sandboxd.db వద్ద ఒకే SQLite ఫైల్‌లో ఉంటుంది మరియు ఎన్‌క్రిప్ట్ చేయబడిన ఏజెంట్ క్రెడెన్షియల్స్ agent-auth/ లో ఉంటాయి. కంటైనర్ లేయర్ లోపల ఏదీ దాచబడదు, కాబట్టి బ్యాకప్ అంటే ఒక డైరెక్టరీ కాపీ మరియు ఆ డేటాబేస్ ఫైల్ మాత్రమే. VPS పై restic backups ఈ రెండింటినీ నిర్వహిస్తుంది.

sudo ls /var/lib/sandboxed/workspaces
sudo du -sh /var/lib/sandboxed/workspaces/*

Git ఎగుమతి అనేది అదనపు ఫీచర్‌గా కాకుండా, అంతర్నిర్మితంగా ఉంటుంది. API ద్వారా స్టేటస్ మరియు డిఫ్ (diff) లను చదవవచ్చు, ఆపై commit మరియు push చేయవచ్చు:

curl -s $API/v1/apps/$APP/git/status -H "$AUTH"

curl -s -XPOST $API/v1/apps/$APP/git/commit -H "$AUTH" \
  -H 'content-type: application/json' \
  -d '{"message":"todo list, first pass"}'

curl -s -XPOST $API/v1/apps/$APP/git/push -H "$AUTH" \
  -H 'content-type: application/json' -d '{"branch":"main"}'

ప్రైవేట్ రిమోట్ కోసం పర్సనల్ యాక్సెస్ టోకెన్ అవసరం, దీనిని కన్సోల్‌లోని Settings, Git credentials విభాగంలో ఒక్కసారి సెట్ చేయాలి. ఇది ఎన్‌క్రిప్ట్ చేయబడి శాండ్‌బాక్స్ వెలుపల నిల్వ చేయబడుతుంది, కాబట్టి ఏజెంట్ దీనిని చదవలేదు లేదా మీ అనుమతి లేకుండా push చేయలేదు. తరచుగా మరియు ముందుగానే push చేయండి. మీరు అలా చేసే వరకు, వర్క్‌స్పేస్ డైరెక్టరీ మాత్రమే కోడ్ యొక్క ఏకైక కాపీగా ఉంటుంది మరియు DELETE /v1/apps/<id> దానిని తొలగిస్తే తిరిగి పొందే అవకాశం ఉండదు.

బిల్డ్ చేయడానికి మోడల్ టోకెన్ల పరంగా ఎంత ఖర్చవుతుంది?

sandboxd మీ ఖర్చును లెక్కించదు, కాబట్టి మీ ప్రొవైడర్ కన్సోల్‌లో ఉన్న సంఖ్యే ప్రామాణికం. ఉచిత OpenCode Zen మోడల్స్‌కు ఎటువంటి ఖర్చు ఉండదు, కానీ ఇవి పెయిడ్ మోడల్స్ కంటే నెమ్మదిగా మరియు తక్కువ సామర్థ్యం కలిగి ఉంటాయి; చిన్న అప్లికేషన్లు కాకుండా వేటికైనా ఇవి ఎక్కువ సార్లు సరిదిద్దాల్సి వస్తుంది.

బిల్లు మొత్తం ఏజెంట్ లూప్ ఎలా పనిచేస్తుందనే దానిపై ఆధారపడి ఉంటుంది. ప్రతి టర్న్ (turn) తనకు అవసరమైన కాంటెక్స్ట్‌ను మళ్ళీ పంపుతుంది, కాబట్టి ఖర్చు అనేది అప్లికేషన్ల సంఖ్యపై కాకుండా, టర్న్ల సంఖ్యపై ఆధారపడి ఉంటుంది. ఒక ప్రాంప్ట్ పంపడం చౌకగానే ఉంటుంది. యాభై ఫైళ్లు ఉన్న ప్రాజెక్ట్‌లో "ఇప్పుడు స్పేసింగ్‌ను సరిచేయి" అని పదిహేను సార్లు అడిగితే ఖర్చు పెరుగుతుంది, ఎందుకంటే ప్రతిసారీ ఫైల్ కంటెంట్ కూడా పంపబడుతుంది. ఇన్‌పుట్ మరియు అవుట్‌పుట్ టోకెన్లకు వేర్వేరు ధరలు ఉంటాయి, మరియు ఒక కోడింగ్ ఏజెంట్‌కు సెషన్‌కు ఎంత ఖర్చవుతుందో చూస్తే వాస్తవిక ధరల పరిధి అర్థమవుతుంది. పర్యవేక్షణ లేని లూప్‌ను రన్ చేసే ముందు, ప్రొవైడర్ వద్ద ఖర్చుపై ఒక గరిష్ట పరిమితిని (hard spend limit) సెట్ చేయండి.

పాతబడిన (stale) శాండ్‌బాక్స్‌లను తొలగించడం

idle reaper, SANDBOXD_IDLE_THRESHOLD_SECONDS దాటి నిష్క్రియంగా ఉన్న ఏ శాండ్‌బాక్స్‌నైనా ఆపివేస్తుంది. ఇది డిఫాల్ట్‌గా 2100 సెకన్లు లేదా 35 నిమిషాలకు సెట్ చేయబడి ఉంటుంది. ఇది RAMను తిరిగి విడుదల చేస్తుంది మరియు ఫైళ్లను అలాగే ఉంచుతుంది; ఆ తర్వాత preview URLకి వచ్చే తదుపరి అభ్యర్థన కంటైనర్‌ను తిరిగి మేల్కొల్పుతుంది. తక్కువ సామర్థ్యం గల సర్వర్లలో దీనిని తగ్గించండి, ఎందుకంటే 35 నిమిషాల పాటు నిష్క్రియంగా ఉన్న కంటైనర్లు మీరు ఉపయోగించలేని 35 నిమిషాల మెమరీని వృథా చేస్తాయి.

ఆపివేయడం అంటే తొలగించడం కాదు, ఇక్కడే డిస్క్ స్పేస్ నిశ్శబ్దంగా నిండిపోతుంది. ఆపివేయబడిన శాండ్‌బాక్స్ తన వర్క్‌స్పేస్‌ను మరియు కంటైనర్‌ను ఇంకా కలిగి ఉంటుంది. శాండ్‌బాక్స్‌ను తొలగించి, అప్లికేషన్‌ను అలాగే ఉంచడం అనేది శాండ్‌బాక్స్‌పై చేసే DELETE చర్య, ఇది కంటైనర్‌ను మరియు వర్క్‌స్పేస్‌ను కూడా తొలగిస్తుంది. అప్లికేషన్‌ను తొలగిస్తే మాత్రం అన్నీ శాశ్వతంగా తొలగిపోతాయి.

curl -s -XPOST $API/v1/sandboxes/$SB/stop -H "$AUTH"     # frees RAM, keeps files
curl -s -XDELETE $API/v1/sandboxes/$SB -H "$AUTH"        # container and workspace gone
curl -s -XDELETE $API/v1/apps/$APP -H "$AUTH"            # app and everything under it

కొన్ని వారాల ప్రయోగాల తర్వాత, docker system df మీరు ఊహించిన దానికంటే ఎక్కువ తిరిగి పొందగలిగే (reclaimable) ఇమేజ్ స్థలాన్ని చూపుతుంది, ఎందుకంటే తన సొంత టూల్‌చైన్‌ను పుల్ చేసుకున్న ప్రతి అప్లికేషన్ కొన్ని లేయర్లను వదిలివేస్తుంది. docker image prune అటువంటి నిరుపయోగమైన (dangling) లేయర్లను క్లియర్ చేస్తుంది. ముందుగా GET /v1/appsని తనిఖీ చేయండి, ఎందుకంటే స్లీపింగ్ శాండ్‌బాక్స్ ద్వారా ఇంకా రిఫరెన్స్ చేయబడుతున్న ఇమేజ్ గార్బేజ్ (చెత్త) కిందకు రాదు.

కంటైనర్ బౌండరీ మీకు ఏమి ఇస్తుంది, ఏమి ఇవ్వదు

ప్రతి శాండ్‌బాక్స్ ఒక unprivileged యూజర్‌గా, read-only root filesystem తో నడుస్తుంది. ఇందులో అన్ని Linux capabilities తొలగించబడతాయి, no-new-privileges సెట్ చేయబడుతుంది, మరియు మెమరీ, ప్రాసెస్ పరిమితులు విధించబడతాయి. ఈ పరిమితుల గురించి ప్రాజెక్ట్ స్పష్టంగా చెబుతోంది: షేర్డ్ కెర్నల్ ఉన్న Linux కంటైనర్ అనేది బలమైన ఐసోలేషన్ బౌండరీ, కానీ బలహీనమైన సెక్యూరిటీ బౌండరీ. కెర్నల్‌లో ఏదైనా బగ్ ఉంటే అది హోస్ట్ సర్వర్ రాజీ పడటానికి (compromise) దారితీస్తుంది.

రెండు విషయాల పట్ల జాగ్రత్త అవసరం. సెల్ఫ్-హోస్టెడ్ బిల్డ్‌లో శాండ్‌బాక్స్ నుండి బయటకు వెళ్లే నెట్‌వర్క్ ట్రాఫిక్ (egress) అనుమతించబడుతుంది, కాబట్టి జనరేట్ అయిన కోడ్ ఇంటర్నెట్‌ను, మీ లోకల్ నెట్‌వర్క్‌ను మరియు క్లౌడ్ మెటాడేటా ఎండ్‌పాయింట్‌లను చేరుకోగలదు. సోర్స్ కోడ్‌లో nftables egress సబ్‌సిస్టమ్ ఉన్నప్పటికీ, పోర్టబుల్ Docker Compose బిల్డ్‌లో అది డిసేబుల్ చేయబడింది. అంటే, ఈ పరిమితులను మీ హోస్ట్ ఫైర్‌వాల్ ద్వారానే మీరు అమలు చేయాలి. అలాగే, కంట్రోల్ ప్లేన్ API అనేది వాస్తవానికి హోస్ట్ రూట్ అధికారాలను కలిగి ఉంటుంది, ఎందుకంటే ఇది Docker socket ను నియంత్రిస్తుంది. ఇది డిఫాల్ట్‌గా 127.0.0.1:9090 కి బైండ్ అవుతుంది, SANDBOXD_API_AUTH_DISABLED ఎల్లప్పుడూ false గానే ఉండాలి, మరియు దీనిని ఎట్టి పరిస్థితుల్లోనూ ఇంటర్నెట్‌కు పబ్లిష్ చేయకూడదు.

ఒకవేళ మీరు ఇతరులను మీ బాక్స్‌కు ప్రాంప్ట్‌లు పంపేలా అనుమతించాలనుకుంటే, ఈ మోడల్ ఒంటరిగా సరిపోదు. ఈ ప్రాజెక్ట్ SANDBOXD_RUNTIME=runsc తో gVisor ను ఉపయోగించమని సూచిస్తుంది. ఇది శాండ్‌బాక్స్‌కు మరియు హోస్ట్‌కు మధ్య ఒక యూజర్‌స్పేస్ కెర్నల్‌ను ఉంచుతుంది, దీనివల్ల syscall ఎక్కువగా ఉండే పనుల వేగం సుమారు 1.7 నుండి 4 రెట్లు తగ్గుతుంది. మరింత బలమైన పరిష్కారం ఏమిటంటే, ప్రతి యూజర్‌కు ఒక ప్రత్యేక మెషీన్‌ను కేటాయించడం. దీని గురించి కోడింగ్ ఏజెంట్లను డిస్పోజబుల్ VMలలో రన్ చేయడం అనే విభాగంలో వివరించిన వాదననే ఇక్కడ కూడా వర్తిస్తుంది.

రెండు నెలల క్రితం ప్రారంభమైన ప్రాజెక్ట్‌పై ఆధారపడాలా?

వ్యక్తిగత బిల్డ్ బాక్స్ కోసం అయితే, అవును, కానీ కొన్ని జాగ్రత్తలు తప్పనిసరి: SANDBOXD_REF ను పిన్ చేయండి, /var/lib/sandboxed ను బ్యాకప్ తీసుకోండి, మరియు మీకు ముఖ్యమైన ప్రతి అప్లికేషన్‌ను ఒక git రిమోట్‌కు పుష్ చేయండి. కస్టమర్లు ఉపయోగించే ఏ ప్రాజెక్ట్ కైనా, 1.0 వెర్షన్ వచ్చే వరకు వేచి ఉండండి లేదా ఏదైనా సమస్య వస్తే దాన్ని సరిచేయడానికి బడ్జెట్ కేటాయించండి. ఎందుకంటే 0.x వెర్షన్లలో మార్పులు వచ్చే అవకాశం ఉందని డెవలపర్లు స్పష్టంగా పేర్కొన్నారు. ఆగస్టు 2026 నాటికి, డెవలపర్లు నెలకు 79 డాలర్ల ధరతో మేనేజ్డ్ ఇన్‌స్టాల్ సేవలను కూడా అందిస్తున్నారు. ప్రాజెక్ట్ భవిష్యత్తులో కొనసాగుతుందా లేదా అని అంచనా వేసేటప్పుడు ఈ విషయం తెలుసుకోవడం ఉపయోగకరం.

ఈ రిస్క్ తీసుకోవడానికి ప్రధాన కారణం దాని అవుట్‌పుట్. sandboxd ఒక సాధారణ git రిపోజిటరీలో సాధారణ అప్లికేషన్‌ను రూపొందిస్తుంది. కాబట్టి, ప్రాజెక్ట్ ఆగిపోయినా, మీ కోడ్ మీ దగ్గరే ఉంటుంది, కేవలం wrapper మాత్రమే కోల్పోతారు. మీ ప్రాజెక్ట్‌పై యాజమాన్యం కలిగి ఉండే హోస్టెడ్ బిల్డర్లతో పోలిస్తే ఇది చాలా మెరుగైన పరిస్థితి. ఈ ఏడాది మీ సర్వర్‌లో దేనికి చోటు కల్పించాలో తెలుసుకోవడానికి, 2026లో self-hosting కోసం ఏవి విలువైనవి చూడండి.

FAQ

sandboxd కోసం కనీస సర్వర్ స్పెసిఫికేషన్లు ఏమిటి?

కంట్రోల్ ప్లేన్, Traefik మరియు ఒక చిన్న శాండ్‌బాక్స్‌ను ప్రారంభించడానికి 2 vCPU మరియు 4 GB RAM సరిపోతాయని ప్రాజెక్ట్ పేర్కొంది. మీరు ఒకే సమయంలో అనేక అప్లికేషన్లను రన్ చేయాలనుకుంటే 8 GB RAM మరియు 40 GB డిస్క్ స్పేస్ ఉపయోగించండి, ఎందుకంటే ప్రతి రన్నింగ్ శాండ్‌బాక్స్ పూర్తి Node లేదా Python టూల్‌చైన్‌ను కలిగి ఉంటుంది మరియు ప్రతి వర్క్‌స్పేస్ తన సొంత డిపెండెన్సీ ట్రీని డిస్క్‌లో ఉంచుకుంటుంది. హోస్ట్ మెషీన్‌లో వనరులు తగ్గినప్పుడు, sandboxd యొక్క ప్రెజర్ రీపర్ మెమరీని ఖాళీ చేయడానికి శాండ్‌బాక్స్‌లను ఆపివేస్తుంది. కంటైనర్ మెమరీ పరిమితిని మించిన బిల్డ్ ప్రక్రియను కెర్నల్ నిలిపివేస్తుంది: దీని కోసం docker ps -a ఎగ్జిట్ కోడ్ 137ను చూపుతుంది.

Dify లేదా OpenHands తో పోలిస్తే sandboxd ఎలా భిన్నమైనది?

ఇవి వేర్వేరు ఫలితాలను (artifacts) ఉత్పత్తి చేస్తాయి. Dify అనేది చాట్ ఇంటర్‌ఫేస్‌లు మరియు రిట్రీవల్ పైప్‌లైన్‌ల వంటి రన్‌టైమ్‌లో మోడల్‌ను పిలిచే అప్లికేషన్‌లను నిర్మిస్తుంది. OpenHands మీరు ఇప్పటికే కలిగి ఉన్న రిపోజిటరీని ఎడిట్ చేస్తుంది, కమాండ్‌లను రన్ చేస్తుంది మరియు ఉన్న కోడ్‌కు మార్పులను సూచిస్తుంది. sandboxd ప్రాంప్ట్ నుండి సరికొత్త ప్రాజెక్ట్‌ను స్కాల్ఫోల్డ్ చేస్తుంది, దానిని సొంత కంటైనర్‌లో నిర్మిస్తుంది మరియు ప్రివ్యూ URL వద్ద అందిస్తుంది. ఫలితంగా వచ్చేది సాధారణ వెబ్ అప్లికేషన్, ఇది రన్ అవ్వడానికి మోడల్ అవసరం లేదు.

ఏజెంట్ రాసే కోడ్ వాస్తవానికి ఎక్కడ ఉంటుంది?

ఇది కంటైనర్ ఇమేజ్ లోపల కాకుండా, హోస్ట్ ఫైల్‌సిస్టమ్‌లో ఉంటుంది. ప్రతి యాప్‌కు /var/lib/sandboxed/workspaces/<id>/ వద్ద ఒక డైరెక్టరీ కేటాయించబడుతుంది, ఇది దాని శాండ్‌బాక్స్‌లోకి బైండ్ మౌంట్ చేయబడుతుంది మరియు ఫైల్‌లు లోపల /home/sandbox/workspace/app వద్ద కనిపిస్తాయి. కంట్రోల్ ప్లేన్ స్థితి అదే డేటా డైరెక్టరీలోని state/ వద్ద ఒకే SQLite ఫైల్‌లో ఉంటుంది. మీరు కన్సోల్ యొక్క Git ట్యాబ్ నుండి లేదా /v1/apps/<id>/git/commit మరియు /git/push ఎండ్‌పాయింట్ల ద్వారా git రిమోట్‌కు కమిట్ మరియు పుష్ చేయవచ్చు. ప్రైవేట్ రిమోట్‌ల కోసం టోకెన్ శాండ్‌బాక్స్‌కు ఇవ్వబడదు, బదులుగా కంట్రోల్ ప్లేన్ ద్వారా ఎన్‌క్రిప్ట్ చేయబడి నిల్వ చేయబడుతుంది.

sandboxd ను ఇంటర్నెట్‌కు ఎక్స్‌పోజ్ చేయడం సురక్షితమేనా?

ప్రివ్యూ URLలు మరియు కన్సోల్‌ను మాత్రమే ఎక్స్‌పోజ్ చేయండి, కంట్రోల్ ప్లేన్ APIని ఎప్పుడూ చేయవద్దు. ఆ API హోస్ట్‌పై Dockerను నియంత్రిస్తుంది, కాబట్టి ఇది root యాక్సెస్‌తో సమానం, అందుకే ఇది డిఫాల్ట్‌గా 127.0.0.1:9090 కి బైండ్ అవుతుంది. సెల్ఫ్-హోస్టెడ్ బిల్డ్‌లో శాండ్‌బాక్స్‌లకు ఓపెన్ నెట్‌వర్క్ ఎగ్రెస్ ఉంటుంది, అంటే ఏజెంట్ రాసే కోడ్ మీ లోకల్ నెట్‌వర్క్ మరియు క్లౌడ్ మెటాడేటా ఎండ్‌పాయింట్‌లను చేరుకోగలదు. కాబట్టి, రక్షించాల్సిన ఇతర సర్వర్లు మీ నెట్‌వర్క్‌లో ఉంటే హోస్ట్ ఫైర్‌వాల్ నియమాలను జోడించండి. మీరు నమ్మని వ్యక్తుల నుండి వచ్చే ప్రాంప్ట్‌ల కోసం, కంటైనర్ బౌండరీపై మాత్రమే ఆధారపడకుండా ప్రతి టెనెంట్‌కు ఒక హోస్ట్‌ను రన్ చేయండి.